refactoring

* basic ctb config api for register and bit names

* tests for define and definelist pass. yet to implement using them for reg, setbit, clearbit and getbit

* improved autocomplete for getbit,setbit, clearbit

* validate autocomplete

* definelist has no put

* updating help

* converting char array+int in runtimeerror compiles but throws at runtime.Fixed.Tested for it. Also check if string or int before using getregisterdefinitonbyvalue to see if it threw to call the other function. because both of it can throw and we should differentiate the issues for both

* removed std::vector<std::pair<string,int> to std::map<string, int> for defiitions list

* Dev/define cmd tie bit to reg (#1328)

* strong type

* moved everythign to bit_utils class

* pybindings

* added tests for python

* removed duplicates

* removed bit names in reg

* changed BitPosition to BitAddress

* Using define reg/bit from python (#1344)

* define_bit, define_addr in python. 
* setBit/clearBit takes int or addr

* added example using bits

* split define into 2 commands define_reg and define_bit, definelist into 2: definelist_reg and definelist_bit

* allow string for register and bit names in c++ api

* refactor from github comments

* naming refactoring (getRegisterDefnition to retunr name and address specifically

* added marker for 8 cmd tests connected to define, changed macro to static constexpr

* changed bitPosition from int to uint32_t

* got rid of setbitposition and setaddress, instead overloaded constructor to take in strings so that the conversion from string to bit address members, takes place within the class for easy maintainance in case type changes

* Removing implicit conversions:
RegisterAddresss and RegisterValue: Removed the implicit conversions.
RegisterAddress: Changed member name from address_ to value_ and method as well to value().
RegisterValue: Also added | operator to be able to concatenate with uint32_t. Same in python bindings (but could not find the tests to modify

* Allowed concatenation with other RegisterValue, made them all constexpr

* fix a ctbConfig test

* Maponstack works with integration tests, but need unit tests

* tests on mapstack

* fixed ctb tests and FixedString being initialized with gibberish

* removing parsing from string inside the class RegisterAddress, BitAddress and RegisterValue

* updated python bindings

* fixed bit utils test

* renaming getRegisterDefintiionAddress/Name=>getRegisterAddress/Name and similary for getBitDefinitionAddress/Name

* updated python bindings

* fix tests (format)

* a few python tests added and python bindings corrected

* replaceing str with __str__ for bit.cpp

* repr reimplemented for bit.cpp

* removed make with registerAddress etc

* starting server for tests per session and nor module

* killprocess throws if no process found-> github runs fails, changed to pkill and not throw

* clean shm shouldnt raise, in ci binary not found

* ignoring these tests for CI, which fail on CI because simulators are not generated in CI. This is in another PR, where it should work

---------

Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com>
Co-authored-by: froejdh_e <erik.frojdh@psi.ch>

.clang-tidy

@@ -28,9 +28,7 @@ Checks:          '*,
                     -modernize-use-trailing-return-type,
                     -llvmlibc-*'
 
-# HeaderFilterRegex: \.h
-HeaderFilterRegex: '^(?!.*([/\\])libs([/\\])).*'
-#AnalyzeTemporaryDtors: false
+HeaderFilterRegex: \.h
 FormatStyle:     none
 CheckOptions:
   - { key: readability-identifier-naming.NamespaceCase,       value: lower_case }

docs/CMakeLists.txt

@@ -11,7 +11,8 @@ add_executable(gendoc src/gendoc.cpp)
 # This is a bit hacky, but better than exposing stuff? 
 target_include_directories(gendoc PRIVATE ${PROJECT_SOURCE_DIR}/slsDetectorSoftware/src)
 target_link_libraries(gendoc PRIVATE
-  slsDetectorShared
+  slsDetectorStatic
+
 )
 set_target_properties(gendoc PROPERTIES 
   RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin

docs/src/gendoc.cpp

@@ -19,7 +19,7 @@ std::string replace_all(const std::string &src, const std::string &from,
                         const std::string &to) {
 
     std::string results;
-    std::string::const_iterator const end = src.end();
+    std::string::const_iterator end = src.end();
     std::string::const_iterator current = src.begin();
     std::string::const_iterator next =
         std::search(current, end, from.begin(), from.end());

python/CMakeLists.txt

@@ -12,6 +12,7 @@ pybind11_add_module(_slsdet
     src/duration.cpp
     src/DurationWrapper.cpp
     src/pedestal.cpp
+    src/bit.cpp
 )
 
 target_link_libraries(_slsdet PUBLIC 

python/scripts/generate_functions.py

@@ -8,6 +8,7 @@ to be installed.
 When the Detector API is updated this file should be run
 manually.
 """
+import os
 from clang import cindex
 import subprocess
 import argparse
@@ -33,6 +34,24 @@ def green(msg):
     return f"{GREENC}{msg}{ENDC}"
 
 
+def find_libclang():
+    """Find libclang in the current Conda/Mamba environment."""
+    conda_prefix = os.environ.get("CONDA_PREFIX")
+    if conda_prefix:
+        lib_dir = os.path.join(conda_prefix, "lib")
+        # Look for libclang*.so files
+        for f in os.listdir(lib_dir):
+            if f.startswith("libclang") and f.endswith(".so"):
+                return os.path.join(lib_dir, f)
+
+    # fallback: system-wide search
+    path = ctypes.util.find_library("clang")
+    if path:
+        return path
+
+    raise FileNotFoundError("libclang not found in CONDA_PREFIX or system paths.")
+
+
 def check_libclang_version(required="12"):
     # Use already-loaded libclang, or let cindex resolve it
     lib = ctypes.CDLL(cindex.Config.library_file or ctypes.util.find_library("clang"))
@@ -202,6 +221,8 @@ if __name__ == "__main__":
     )
     cargs = parser.parse_args()
     
+    libclang_path = find_libclang()
+    cindex.Config.set_library_file(libclang_path)
     check_libclang_version("12")
     check_clang_format_version(12)
     check_for_compile_commands_json(cargs.build_path)

python/slsdet/__init__.py

@@ -27,6 +27,9 @@ from .defines import *
 
 IpAddr = _slsdet.IpAddr
 MacAddr = _slsdet.MacAddr
+RegisterAddress = _slsdet.RegisterAddress
+BitAddress = _slsdet.BitAddress
+RegisterValue = _slsdet.RegisterValue
 scanParameters = _slsdet.scanParameters
 currentSrcParameters = _slsdet.currentSrcParameters
 DurationWrapper = _slsdet.DurationWrapper

python/slsdet/detector.py

@@ -3,6 +3,7 @@
 from ._slsdet import CppDetectorApi
 from ._slsdet import slsDetectorDefs
 from ._slsdet import IpAddr, MacAddr
+from ._slsdet import RegisterAddress, RegisterValue, BitAddress
 
 runStatus = slsDetectorDefs.runStatus
 timingMode = slsDetectorDefs.timingMode
@@ -1814,6 +1815,148 @@ class Detector(CppDetectorApi):
         """
         return self._register
     
+    def define_reg(self, *, name: str, addr):
+        """
+        [Ctb] Define a name for a register to be used later with reg.
+
+        Example
+        --------
+
+        d.define_reg('myreg',addr=0x6)
+        d.define_reg('myreg',addr=RegisterAddress(0x6))')
+        """
+        if isinstance(addr, int):
+            addr = RegisterAddress(addr)
+        elif not isinstance(addr, RegisterAddress):
+            raise ValueError("addr must int or RegisterAddress")
+        self.setRegisterDefinition(name, addr)
+
+
+    def define_bit(self, *, name: str, addr, bit_position:int=None):
+        """
+        [Ctb] Define a name for a bit in a register to be used later with setBit/clearBit/getBit
+
+        Example
+        --------
+
+        bit1 = BitAddress(RegisterAddress(0x6),7)
+        d.define_bit('mybit',addr=bit1)
+        d.define_bit('mybit',addr=0x6, bit=7)
+        d.define_bit('mybit',addr=RegisterAddress(0x6), bit=7)
+        d.define_bit('mybit',addr='myreg', bit=7) #if myreg defined before
+        """
+
+        # bitAddress
+        if isinstance(addr, BitAddress):
+            if bit_position is not None:
+                raise ValueError("If addr is BitAddress, bit_position must be None")
+            bitaddr = addr
+        # register name/address + bit_position
+        else:
+            if isinstance(addr, str):
+                addr = self.getRegisterAddress(addr)
+            elif isinstance(addr, int):
+                addr = RegisterAddress(addr)
+            elif not isinstance(addr, RegisterAddress):
+                raise ValueError("addr must be str, int or RegisterAddress")
+            
+            if bit_position is None:
+                raise ValueError("bit_position must be provided if addr is used.")
+            if not isinstance(bit_position, int):
+                raise ValueError("bit_position must be int")
+
+            bitaddr = BitAddress(addr, bit_position)
+
+        self.setBitDefinition(name, bitaddr)
+
+    def _resolve_bit_name_or_addr(self, bitname_or_addr, bit_position=None):
+        """
+        Internal function to resolve bit name or address arguments for setBit, clearBit and getBit
+        Returns a BitAddress
+        """
+        #Old usage passing two ints  or [RegisterAddress and int]
+        if isinstance(bitname_or_addr, (int, RegisterAddress)):
+            if bit_position is None:
+                raise ValueError("bit_position must be provided when passing int address")
+            if not isinstance(bit_position, int):
+                raise ValueError("bit_position must be int")
+            return BitAddress(bitname_or_addr, bit_position)
+
+        # New usage with str or BitAddress
+        # str
+        if isinstance(bitname_or_addr, str):
+            bitname_or_addr = self.getBitAddress(bitname_or_addr)
+
+        if bit_position is not None:
+            raise ValueError("bit_position must be None when passing str or BitAddress")
+
+        #must now be a BitAddress
+        if not isinstance(bitname_or_addr, BitAddress):
+            raise ValueError("bitname_or_addr must be str, BitAddress, int or RegisterAddress")
+
+        return bitname_or_addr
+        
+
+    def setBit(self, bitname_or_addr, bit_position=None):
+        """
+        Set a bit in a register
+        [Ctb] Can use a named bit address
+
+        Example
+        --------
+        d.setBit(0x5, 3)
+        d.setBit(RegisterAddress(0x5), 3)
+        
+        #Ctb
+        d.setBit('mybit')
+
+        myreg = RegisterAddress(0x5)
+        mybit = BitAddress(myreg, 5) 
+        d.setBit(mybit)
+        """
+        resolved = self._resolve_bit_name_or_addr(bitname_or_addr, bit_position)
+        return super().setBit(resolved)
+        
+    def clearBit(self, bitname_or_addr, bit_position=None):
+        """
+        Clear a bit in a register
+        [Ctb] Can use a named bit address
+
+        Example
+        --------
+        d.clearBit(0x5, 3)
+        
+        #Ctb
+        d.clearBit('mybit')
+
+        myreg = RegisterAddress(0x5)
+        mybit = BitAddress(myreg, 5) 
+        d.clearBit(mybit)
+        """
+        resolved = self._resolve_bit_name_or_addr(bitname_or_addr, bit_position)
+        return super().clearBit(resolved)
+
+    @element
+    def getBit(self, bitname_or_addr, bit_position=None):
+        """
+        Get a bit from a register
+        [Ctb] Can use a named bit address
+
+        Example
+        --------
+        d.getBit(0x5, 3)
+        
+        #Ctb
+        d.getBit('mybit')
+
+        myreg = RegisterAddress(0x5)
+        mybit = BitAddress(myreg, 5) 
+        d.getBit(mybit)
+        """
+        resolved = self._resolve_bit_name_or_addr(bitname_or_addr, bit_position)
+        return super().getBit(resolved)  
+
+
     @property
     def slowadc(self):
         """

python/slsdet/registers.py

@@ -1,13 +1,30 @@
 # SPDX-License-Identifier: LGPL-3.0-or-other
 # Copyright (C) 2021 Contributors to the SLS Detector Package
+
+from ._slsdet import RegisterValue, RegisterAddress
+from .utils import element
+
 class Register:
     def __init__(self, detector):
         self._detector = detector
 
+    @element
     def __getitem__(self, key):
+        if isinstance(key, str):
+            key = self._detector.getRegisterAddress(key)
+        elif isinstance(key, int):
+            key = RegisterAddress(key)
         return self._detector.readRegister(key)
 
     def __setitem__(self, key, value):
+        if isinstance(key, str):
+            key = self._detector.getRegisterAddress(key)
+        elif isinstance(key, int):
+            key = RegisterAddress(key)
+
+        if isinstance(value, int):
+            value = RegisterValue(value)
+
         self._detector.writeRegister(key, value, False)
 
 class Adc_register:

python/slsdet/utils.py

@@ -141,20 +141,19 @@ def make_ip(arg):
 def make_mac(arg):
     return _make(arg, _slsdet.MacAddr)
 
-
 def make_path(arg):
     return _make(arg, Path)
 
 
 def _make(arg, transform):
-    """Helper function for make_mac and make_ip special cases for
+    """Helper function for make_mac, make_ip and other special cases for
     dict, list and tuple. Otherwise just calls transform"""
     if isinstance(arg, dict):
-        return {key: transform(value) for key, value in arg.items()}
+        return {key: _make(value, transform) for key, value in arg.items()}
     elif isinstance(arg, list):
-        return [transform(a) for a in arg]
+        return [_make(a, transform) for a in arg]
     elif isinstance(arg, tuple):
-        return tuple(transform(a) for a in arg)
+        return tuple(_make(a, transform) for a in arg)
     else:
         return transform(arg)
 

python/src/bit.cpp

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+/*
+This file contains Python bindings for the RegisterAddr, BitAddress and
+RegisterValue classes.
+*/
+#include "py_headers.h"
+#include "sls/bit_utils.h"
+
+namespace py = pybind11;
+
+using sls::BitAddress;
+using sls::RegisterAddress;
+using sls::RegisterValue;
+
+void init_bit(py::module &m) {
+
+    py::class_<RegisterAddress>(m, "RegisterAddress")
+        .def(py::init())
+        .def(py::init<uint32_t>())
+        .def(py::init<const RegisterAddress &>())
+        .def("__repr__",
+             [](const RegisterAddress &addr) {
+                 return "RegisterAddress(" + addr.str() + ")";
+             })
+        .def("__str__", &RegisterAddress::str)
+        .def("value", &RegisterAddress::value)
+        .def(py::self == py::self)
+        .def(py::self != py::self);
+
+    py::class_<BitAddress>(m, "BitAddress")
+        .def(py::init())
+        .def(py::init<RegisterAddress, uint32_t>())
+        .def("__repr__",
+             [](const BitAddress &addr) {
+                 return "BitAddress(" + addr.str() + ")";
+             })
+        .def("__str__", &BitAddress::str)
+        .def("address", &BitAddress::address)
+        .def("bitPosition", &BitAddress::bitPosition)
+        .def(py::self == py::self)
+        .def(py::self != py::self);
+
+    py::class_<RegisterValue>(m, "RegisterValue")
+        .def(py::init<>())
+        .def(py::init<uint32_t>())
+        .def(py::init<const RegisterValue &>())
+        .def("__repr__",
+             [](const RegisterValue &val) {
+                 return "RegisterValue(" + val.str() + ")";
+             })
+        .def("__str__", &RegisterValue::str)
+        .def("value", &RegisterValue::value)
+        .def(py::self == py::self)
+        .def(py::self != py::self)
+        .def("__or__", [](const RegisterValue &lhs,
+                          const RegisterValue &rhs) { return lhs | rhs; })
+        .def("__or__",
+             [](const RegisterValue &lhs, uint32_t rhs) { return lhs | rhs; })
+        .def(
+            "__ior__",
+            [](RegisterValue &lhs, uint32_t rhs) -> RegisterValue & {
+                lhs |= rhs;
+                return lhs;
+            },
+            py::return_value_policy::reference_internal);
+}

python/src/detector.cpp

@@ -8,6 +8,7 @@
 #include "sls/Detector.h"
 #include "sls/TimeHelper.h"
 #include "sls/ToString.h"
+#include "sls/bit_utils.h"
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
 
@@ -15,10 +16,13 @@
 #include <chrono>
 namespace py = pybind11;
 void init_det(py::module &m) {
+    using sls::BitAddress;
     using sls::defs;
     using sls::Detector;
     using sls::ns;
     using sls::Positions;
+    using sls::RegisterAddress;
+    using sls::RegisterValue;
     using sls::Result;
 
     m.def("freeSharedMemory",
@@ -942,7 +946,6 @@ void init_det(py::module &m) {
                        (void (Detector::*)(const std::vector<defs::ROI> &)) &
                            Detector::setRxROI,
                        py::arg());
-
     CppDetectorApi.def("clearRxROI",
                        (void (Detector::*)()) & Detector::clearRxROI);
     CppDetectorApi.def(
@@ -1796,6 +1799,82 @@ void init_det(py::module &m) {
                        (std::string(Detector::*)(const defs::dacIndex) const) &
                            Detector::getSlowADCName,
                        py::arg());
+    CppDetectorApi.def("getRegisterDefinitionsCount",
+                       (int (Detector::*)() const) &
+                           Detector::getRegisterDefinitionsCount);
+    CppDetectorApi.def(
+        "setRegisterDefinition",
+        (void (Detector::*)(const std::string &, sls::RegisterAddress)) &
+            Detector::setRegisterDefinition,
+        py::arg(), py::arg());
+    CppDetectorApi.def("hasRegisterDefinition",
+                       (bool (Detector::*)(const std::string &) const) &
+                           Detector::hasRegisterDefinition,
+                       py::arg());
+    CppDetectorApi.def("hasRegisterDefinition",
+                       (bool (Detector::*)(sls::RegisterAddress) const) &
+                           Detector::hasRegisterDefinition,
+                       py::arg());
+    CppDetectorApi.def(
+        "getRegisterAddress",
+        (sls::RegisterAddress(Detector::*)(const std::string &) const) &
+            Detector::getRegisterAddress,
+        py::arg());
+    CppDetectorApi.def("getRegisterName",
+                       (std::string(Detector::*)(sls::RegisterAddress) const) &
+                           Detector::getRegisterName,
+                       py::arg());
+    CppDetectorApi.def("clearRegisterDefinitions",
+                       (void (Detector::*)()) &
+                           Detector::clearRegisterDefinitions);
+    CppDetectorApi.def(
+        "setRegisterDefinitions",
+        (void (Detector::*)(const std::map<std::string, RegisterAddress> &)) &
+            Detector::setRegisterDefinitions,
+        py::arg());
+    CppDetectorApi.def(
+        "getRegisterDefinitions",
+        (std::map<std::string, RegisterAddress>(Detector::*)() const) &
+            Detector::getRegisterDefinitions);
+    CppDetectorApi.def("getBitDefinitionsCount",
+                       (int (Detector::*)() const) &
+                           Detector::getBitDefinitionsCount);
+    CppDetectorApi.def(
+        "setBitDefinition",
+        (void (Detector::*)(const std::string &, sls::BitAddress)) &
+            Detector::setBitDefinition,
+        py::arg(), py::arg());
+    CppDetectorApi.def("hasBitDefinition",
+                       (bool (Detector::*)(const std::string &) const) &
+                           Detector::hasBitDefinition,
+                       py::arg());
+    CppDetectorApi.def("hasBitDefinition",
+                       (bool (Detector::*)(sls::BitAddress) const) &
+                           Detector::hasBitDefinition,
+                       py::arg());
+    CppDetectorApi.def("toRegisterNameBitString",
+                       (std::string(Detector::*)(sls::BitAddress) const) &
+                           Detector::toRegisterNameBitString,
+                       py::arg());
+    CppDetectorApi.def(
+        "getBitAddress",
+        (sls::BitAddress(Detector::*)(const std::string &) const) &
+            Detector::getBitAddress,
+        py::arg());
+    CppDetectorApi.def("getBitName",
+                       (std::string(Detector::*)(sls::BitAddress) const) &
+                           Detector::getBitName,
+                       py::arg());
+    CppDetectorApi.def("clearBitDefinitions",
+                       (void (Detector::*)()) & Detector::clearBitDefinitions);
+    CppDetectorApi.def(
+        "setBitDefinitions",
+        (void (Detector::*)(const std::map<std::string, BitAddress> &)) &
+            Detector::setBitDefinitions,
+        py::arg());
+    CppDetectorApi.def("getBitDefinitions", (std::map<std::string, BitAddress>(
+                                                Detector::*)() const) &
+                                                Detector::getBitDefinitions);
     CppDetectorApi.def("configureTransceiver",
                        (void (Detector::*)(sls::Positions)) &
                            Detector::configureTransceiver,
@@ -1969,6 +2048,58 @@ void init_det(py::module &m) {
                        (void (Detector::*)(const bool, sls::Positions)) &
                            Detector::setUpdateMode,
                        py::arg(), py::arg() = Positions{});
+    CppDetectorApi.def("readRegister",
+                       (Result<sls::RegisterValue>(Detector::*)(
+                           sls::RegisterAddress, sls::Positions) const) &
+                           Detector::readRegister,
+                       py::arg(), py::arg() = Positions{});
+    CppDetectorApi.def(
+        "writeRegister",
+        (void (Detector::*)(sls::RegisterAddress, sls::RegisterValue, bool,
+                            sls::Positions)) &
+            Detector::writeRegister,
+        py::arg(), py::arg(), py::arg() = false, py::arg() = Positions{});
+    CppDetectorApi.def(
+        "setBit",
+        (void (Detector::*)(sls::BitAddress, bool, sls::Positions)) &
+            Detector::setBit,
+        py::arg(), py::arg() = false, py::arg() = Positions{});
+    CppDetectorApi.def(
+        "clearBit",
+        (void (Detector::*)(sls::BitAddress, bool, sls::Positions)) &
+            Detector::clearBit,
+        py::arg(), py::arg() = false, py::arg() = Positions{});
+    CppDetectorApi.def(
+        "getBit",
+        (Result<int>(Detector::*)(sls::BitAddress, sls::Positions) const) &
+            Detector::getBit,
+        py::arg(), py::arg() = Positions{});
+    CppDetectorApi.def("readRegister",
+                       (Result<sls::RegisterValue>(Detector::*)(
+                           const std::string &, sls::Positions) const) &
+                           Detector::readRegister,
+                       py::arg(), py::arg() = Positions{});
+    CppDetectorApi.def(
+        "writeRegister",
+        (void (Detector::*)(const std::string &, sls::RegisterValue, bool,
+                            sls::Positions)) &
+            Detector::writeRegister,
+        py::arg(), py::arg(), py::arg() = false, py::arg() = Positions{});
+    CppDetectorApi.def(
+        "setBit",
+        (void (Detector::*)(const std::string &, bool, sls::Positions)) &
+            Detector::setBit,
+        py::arg(), py::arg() = false, py::arg() = Positions{});
+    CppDetectorApi.def(
+        "clearBit",
+        (void (Detector::*)(const std::string &, bool, sls::Positions)) &
+            Detector::clearBit,
+        py::arg(), py::arg() = false, py::arg() = Positions{});
+    CppDetectorApi.def(
+        "getBit",
+        (Result<int>(Detector::*)(const std::string &, sls::Positions) const) &
+            Detector::getBit,
+        py::arg(), py::arg() = Positions{});
     CppDetectorApi.def(
         "readRegister",
         (Result<uint32_t>(Detector::*)(uint32_t, sls::Positions) const) &
@@ -1991,7 +2122,7 @@ void init_det(py::module &m) {
         py::arg(), py::arg(), py::arg() = false, py::arg() = Positions{});
     CppDetectorApi.def(
         "getBit",
-        (Result<int>(Detector::*)(uint32_t, int, sls::Positions)) &
+        (Result<int>(Detector::*)(uint32_t, int, sls::Positions) const) &
             Detector::getBit,
         py::arg(), py::arg(), py::arg() = Positions{});
     CppDetectorApi.def("executeFirmwareTest",

python/src/detector_in.cpp

@@ -7,15 +7,19 @@
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
 #include "sls/TimeHelper.h"
+#include "sls/bit_utils.h"
 
 #include <array>
 #include <chrono>
 namespace py = pybind11;
 void init_det(py::module &m) {
+    using sls::BitAddress;
     using sls::defs;
     using sls::Detector;
     using sls::ns;
     using sls::Positions;
+    using sls::RegisterAddress;
+    using sls::RegisterValue;
     using sls::Result;
 
     m.def("freeSharedMemory", (void (*)(const int, const int)) &sls::freeSharedMemory, py::arg() = 0, py::arg() = -1);

python/src/duration.cpp

@@ -24,7 +24,7 @@ void init_duration(py::module &m) {
     m.def(
         "test_return_DurationWrapper",
         []() {
-            DurationWrapper const t(1.3);
+            DurationWrapper t(1.3);
             return t;
         },
         R"(

python/src/enums.cpp

@@ -9,7 +9,7 @@
 #include "sls/sls_detector_defs.h"
 namespace py = pybind11;
 void init_enums(py::module &m) {
-    py::class_<slsDetectorDefs> const Defs(m, "slsDetectorDefs");
+    py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
     py::class_<slsDetectorDefs::xy> xy(m, "xy");
     xy.def(py::init());
     xy.def(py::init<int, int>());

python/src/main.cpp

@@ -20,6 +20,7 @@ void init_scan(py::module &);
 void init_source(py::module &);
 void init_duration(py::module &);
 void init_pedestal(py::module &);
+void init_bit(py::module &);
 
 PYBIND11_MODULE(_slsdet, m) {
     m.doc() = R"pbdoc(
@@ -40,6 +41,7 @@ PYBIND11_MODULE(_slsdet, m) {
     init_source(m);
     init_duration(m);
     init_pedestal(m);
+    init_bit(m);
     //  init_experimental(m);
 
     py::module io = m.def_submodule("io", "Submodule for io");

python/src/pattern.cpp

@@ -15,7 +15,7 @@ void init_pattern(py::module &m) {
 
     patternParameters.def(py::init());
     patternParameters.def("numpy_view", [](py::object &obj) {
-        pat  const&o = obj.cast<pat &>();
+        pat &o = obj.cast<pat &>();
         return py::array_t<pat>(1, &o, obj);
     });
 

python/tests/test_CtbAPI.py

@@ -0,0 +1,385 @@
+'''
+cd python/tests
+Specific test: pytest -s -x test_CtbAPI.py::test_define_bit  #-x=abort on first failure
+Specific test with specific server: pytest -s -x test_CtbAPI.py::test_define_reg[ctb]
+
+'''
+
+import pytest, sys, traceback
+
+from pathlib import Path
+current_dir = Path(__file__).resolve().parents[2]
+scripts_dir = current_dir / "tests" / "scripts"
+sys.path.append(str(scripts_dir))
+print(sys.path)
+
+from utils_for_test import (
+    Log,
+    LogLevel,
+    cleanup,
+    startDetectorVirtualServer,
+    connectToVirtualServers,
+    SERVER_START_PORTNO, 
+)
+
+from slsdet import Detector, detectorType
+
+
+@pytest.fixture(
+    scope="session", 
+    params=['ctb', 'xilinx_ctb', 'mythen3']
+)
+def simulator(request):
+    """Fixture to start the detector server once and clean up at the end."""
+    det_name = request.param
+    num_mods = 1
+    fp = sys.stdout
+
+    # set up: once per server
+    Log(LogLevel.INFOBLUE, f'---- {det_name} ----')
+    cleanup(fp)
+    startDetectorVirtualServer(det_name, num_mods, fp)
+
+    Log(LogLevel.INFOBLUE, f'Waiting for server to start up and connect')
+    connectToVirtualServers(det_name, num_mods)
+
+    yield det_name # tests run here
+
+    cleanup(fp)
+
+
+@pytest.mark.withdetectorsimulators
+def test_define_reg(simulator, request):
+    """ Test setting define_reg for ctb and xilinx_ctb."""
+    det_name = simulator
+    from slsdet import RegisterAddress
+
+    d = Detector()
+    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
+
+    if det_name in ['ctb', 'xilinx_ctb']:
+        prev_reg_defs = d.getRegisterDefinitions()
+        prev_bit_defs = d.getBitDefinitions()
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+
+        addr1 = RegisterAddress(0x201)
+        addr2 = RegisterAddress(0x202)
+        d.define_reg(name="test_reg", addr=RegisterAddress(0x200)) # valid
+        d.define_reg(name="test_reg", addr=addr1) # takes a register address
+        d.define_reg(name="test_reg2", addr=0x202) # takes an int
+
+        # not using keyword arguments
+        with pytest.raises(TypeError) as exc_info:
+            d.define_reg("randomreg", 0x203)
+
+        # invalid value type
+        with pytest.raises(Exception) as exc_info:
+            d.define_reg(name="test_reg3", addr='0x203')
+        assert "addr must int or RegisterAddress" in str(exc_info.value)
+
+        # defining with duplicate value
+        with pytest.raises(Exception) as exc_info:
+            d.define_reg(name="test_reg3", addr=addr1)
+        assert "Value already assigned" in str(exc_info.value)
+
+        assert(d.getRegisterAddress("test_reg") == addr1)
+        assert(d.getRegisterName(addr1) == "test_reg")
+
+        # accessing non existent reg name
+        with pytest.raises(Exception) as exc_info:
+            d.reg['random_reg']
+        assert "No entry found for key" in str(exc_info.value)
+
+        # get non existing reg address
+        with pytest.raises(Exception) as exc_info:
+            d.getRegisterName(RegisterAddress(0x300))
+        assert "No entry found for value" in str(exc_info.value)
+
+        d.clearRegisterDefinitions()
+        
+        d.setRegisterDefinitions(prev_reg_defs)
+        d.setBitDefinitions(prev_bit_defs)  
+
+    else:
+        with pytest.raises(Exception) as exc_info:
+            d.define_reg(name="test_reg", addr=0x201)
+        assert "Register Definitions only for CTB" in str(exc_info.value)
+
+    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
+
+
+@pytest.mark.withdetectorsimulators
+def test_define_bit(simulator, request):
+    """ Test setting define_bit for ctb and xilinx_ctb."""
+    det_name = simulator
+    from slsdet import RegisterAddress, BitAddress
+
+    # setup
+    d = Detector()
+    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
+
+    if det_name in ['ctb', 'xilinx_ctb']:
+        prev_reg_defs = d.getRegisterDefinitions()
+        prev_bit_defs = d.getBitDefinitions()
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+
+        addr1 = RegisterAddress(0x201)
+        addr2 = RegisterAddress(0x202)
+        d.define_reg(name="test_reg1", addr=addr1) 
+        d.define_reg(name="test_reg2", addr=addr2)
+
+        # not using keyword arguments
+        with pytest.raises(TypeError) as exc_info:
+            d.define_bit("randombit", 0x203, 1)
+
+        # invalid value type (bit=string)
+        with pytest.raises(ValueError) as exc_info:
+            d.define_bit(name="test_bit1", addr='test_reg1', bit_position='1')
+        
+        # invalid bit_position
+        with pytest.raises(Exception) as exc_info:
+            d.define_bit(name="test_bit1", addr='test_reg1', bit_position=32)
+        assert "Bit position must be between 0 and 31" in str(exc_info.value)
+
+        # defining with random reg value
+        with pytest.raises(Exception) as exc_info:
+            d.define_bit(name='test_bit1', addr='random_reg', bit_position=1)
+        assert "No entry found for key" in str(exc_info.value)
+
+        bit1 = BitAddress(addr1, 2)
+        bit2 = BitAddress(addr1, 4)
+        bit3 = BitAddress(addr2, 3)
+
+        # defining bit address with bit_position as well
+        with pytest.raises(ValueError) as exc_info:
+            d.define_bit(name='test_bit1', addr=bit1, bit_position=1)
+        assert "bit_position must be None" in str(exc_info.value)
+
+
+        d.define_bit(name="test_bit1", addr='test_reg2', bit_position=1)
+        d.define_bit(name="test_bit1", addr='test_reg1', bit_position=1) # modify reg
+        d.define_bit(name='test_bit1', addr=bit1) # modify pos
+        d.define_bit(name="test_bit2", addr=0x201, bit_position=4) # int addr
+        d.define_bit(name="test_bit3", addr=addr2, bit_position=3) # RegisterAddress addr
+
+
+        assert(d.getBitAddress('test_bit1') == bit1)
+        assert(d.getBitAddress('test_bit2') == bit2)
+        assert(d.getBitAddress('test_bit3') == bit3)
+        assert(d.getBitAddress('test_bit1').address() == addr1)
+        assert(d.getBitAddress('test_bit1').bitPosition() == 2)
+        assert(d.getBitAddress('test_bit2') == BitAddress(addr1, 4))
+
+        assert(d.getBitName(bit1) == 'test_bit1')
+        assert(d.getBitName(bit2) == 'test_bit2')
+        assert(d.getBitName(bit3) == 'test_bit3')
+        assert(d.getBitName(BitAddress(addr2,3)) == 'test_bit3')
+
+        # bit doesnt exist for that reg
+        with pytest.raises(Exception) as exc_info:
+            d.getBitName(BitAddress(addr1, 5))
+        assert "No entry found for value" in str(exc_info.value)
+
+        # addr doesnt exist for that reg
+        with pytest.raises(Exception) as exc_info:
+            d.getBitName(BitAddress(RegisterAddress(0x300), 5))
+        assert "No entry found for value" in str(exc_info.value)
+
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+        
+        d.setRegisterDefinitions(prev_reg_defs)
+        d.setBitDefinitions(prev_bit_defs)  
+    else:
+        with pytest.raises(Exception) as exc_info:
+           d.define_bit(name="test_bit", addr=0x300, bit_position=1)
+        assert "Bit Definitions only for CTB" in str(exc_info.value)
+    
+        
+    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
+
+
+@pytest.mark.withdetectorsimulators
+def test_using_defined_reg_and_bit(simulator, request):
+    """ Test using defined reg and bit define_bit for ctb and xilinx_ctb."""
+    det_name = simulator
+    from slsdet import RegisterAddress, BitAddress, RegisterValue
+
+    # setup
+    d = Detector()
+    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
+
+    if det_name in ['ctb', 'xilinx_ctb']:
+        prev_reg_defs = d.getRegisterDefinitions()
+        prev_bit_defs = d.getBitDefinitions()
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+
+        addr1 = RegisterAddress(0x201)
+        addr2 = RegisterAddress(0x202)
+        d.setRegisterDefinition('test_reg1', addr1)
+        d.setRegisterDefinition('test_reg2', addr2)
+        bit1 = BitAddress(addr1, 2)
+        bit2 = BitAddress(addr1, 4)
+        bit3 = BitAddress(addr2, 3)
+        d.setBitDefinition('test_bit1', bit1)
+        d.setBitDefinition('test_bit2', bit2)
+        d.setBitDefinition('test_bit3', bit3)
+
+        prev_val_addr1 = d.reg[addr1]
+        prev_val_addr2 = d.reg[addr2]
+
+        # reg name doesnt exist
+        with pytest.raises(Exception) as exc_info:
+            d.reg['random_reg']
+        assert "No entry found for key" in str(exc_info.value)
+        with pytest.raises(Exception) as exc_info:
+            d.setBit('random_reg')
+        assert "No entry found for key" in str(exc_info.value)
+        with pytest.raises(Exception) as exc_info:
+            d.clearBit('random_reg')
+        assert "No entry found for key" in str(exc_info.value)
+        with pytest.raises(Exception) as exc_info:
+            d.getBit('random_reg')
+        assert "No entry found for key" in str(exc_info.value)
+
+        # bit name doesnt exist
+        with pytest.raises(Exception) as exc_info:
+            d.setBit('test_bit1', bit_position=5)
+        assert "bit_position must be None" in str(exc_info.value)
+        with pytest.raises(Exception) as exc_info:
+            d.clearBit('test_bit1', bit_position=5)
+        assert "bit_position must be None" in str(exc_info.value)
+        with pytest.raises(Exception) as exc_info:
+            d.getBit('test_bit1', bit_position=5)
+        assert "bit_position must be None" in str(exc_info.value)
+
+        d.reg['test_reg1'] = RegisterValue(0x0)
+        assert(d.reg['test_reg1'].value() == 0x0)
+
+        d.reg['test_reg1'] = RegisterValue(0x10)
+        assert(d.reg['test_reg1'].value() == 0x10)
+
+        d.setBit('test_bit1')
+        assert(d.reg['test_reg1'].value() == 0x14) # 0x10 | (1 << 2)
+
+        d.clearBit('test_bit1')
+        assert(d.reg['test_reg1'].value() == 0x10)
+
+        assert(d.getBit('test_bit1') == 0)
+
+        # restore previous values
+        d.reg[addr1] = prev_val_addr1
+        d.reg[addr2] = prev_val_addr2
+
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+        
+        d.setRegisterDefinitions(prev_reg_defs)
+        d.setBitDefinitions(prev_bit_defs)  
+    else:
+        with pytest.raises(Exception) as exc_info:
+            d.define_bit(name="test_bit", addr=0x300, bit_position=1)
+        assert "Bit Definitions only for CTB" in str(exc_info.value)
+
+    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
+
+
+@pytest.mark.withdetectorsimulators
+def test_definelist_reg(simulator, request):
+    """ Test using definelist_reg for ctb and xilinx_ctb."""
+    det_name = simulator
+    from slsdet import RegisterAddress, BitAddress, RegisterValue
+
+    # setup
+    d = Detector()
+    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
+
+    if det_name in ['ctb', 'xilinx_ctb']:
+        prev_reg_defs = d.getRegisterDefinitions()
+        prev_bit_defs = d.getBitDefinitions()
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+
+        addr1 = RegisterAddress(0x201)
+        addr2 = RegisterAddress(0x202)
+        bit1 = BitAddress(addr1, 2)
+        bit2 = BitAddress(addr1, 4)
+        bit3 = BitAddress(addr2, 3)
+
+        d.setRegisterDefinitions({
+            'test_reg1': RegisterAddress(0x201),
+            'test_reg2': RegisterAddress(0x202)
+        })
+
+        res = d.getRegisterDefinitions()
+        assert(res['test_reg1'] == addr1)
+        assert(res['test_reg2'] == addr2)
+        assert(len(res) == 2)
+
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+        
+        d.setRegisterDefinitions(prev_reg_defs)
+        d.setBitDefinitions(prev_bit_defs)  
+    else:
+        with pytest.raises(Exception) as exc_info:
+            d.define_bit(name="test_bit", addr=0x300, bit_position=1)
+        assert "Bit Definitions only for CTB" in str(exc_info.value)
+
+    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
+
+
+@pytest.mark.withdetectorsimulators
+def test_definelist_bit(simulator, request):
+    """ Test using definelist_bit for ctb and xilinx_ctb."""
+    det_name = simulator
+    from slsdet import RegisterAddress, BitAddress, RegisterValue
+
+    # setup
+    d = Detector()
+    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
+
+    if det_name in ['ctb', 'xilinx_ctb']:
+        prev_reg_defs = d.getRegisterDefinitions()
+        prev_bit_defs = d.getBitDefinitions()
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+
+        addr1 = RegisterAddress(0x201)
+        addr2 = RegisterAddress(0x202)
+        bit1 = BitAddress(addr1, 2)
+        bit2 = BitAddress(addr1, 4)
+        bit3 = BitAddress(addr2, 3)
+
+        d.setRegisterDefinitions({
+            'test_reg1': RegisterAddress(0x201),
+            'test_reg2': RegisterAddress(0x202)
+        })
+        d.setBitDefinitions({
+            'test_bit1': BitAddress(addr1, 2),
+            'test_bit2': BitAddress(addr1, 4),
+            'test_bit3': BitAddress(addr2, 3)
+        })
+
+        res = d.getBitDefinitions()
+        assert(len(res) == 3)
+        assert(res['test_bit1'] == bit1)
+        assert(res['test_bit2'] == bit2)
+        assert(res['test_bit3'] == bit3)
+        assert(res['test_bit2'].address() == addr1)
+        assert(res['test_bit2'].bitPosition() == 4) 
+
+        d.clearRegisterDefinitions()
+        d.clearBitDefinitions()
+        
+        d.setRegisterDefinitions(prev_reg_defs)
+        d.setBitDefinitions(prev_bit_defs)  
+    else:
+        with pytest.raises(Exception) as exc_info:
+            d.define_bit(name="test_bit", addr=0x300, bit_position=1)
+        assert "Bit Definitions only for CTB" in str(exc_info.value)
+
+    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")

python/tests/test_utils.py

@@ -8,7 +8,7 @@ Testing functions from utils.py
 
 import pytest
 from slsdet.utils import *
-from slsdet import IpAddr, MacAddr, DurationWrapper
+from slsdet import IpAddr, MacAddr, DurationWrapper, RegisterAddress, RegisterValue, BitAddress
 import datetime as dt
 import pathlib
 from pathlib import Path
@@ -199,6 +199,7 @@ def test_make_mac_from_tuple():
                              MacAddr("84:a9:3e:24:32:aa"))
 
 
+
 def test_make_path_from_str():
     assert make_path("/") == Path("/")
     assert make_path("/home") == Path("/home")

sample/CMakeLists.txt

@@ -4,12 +4,20 @@ add_executable(using_logger using_logger.cpp)
 target_link_libraries(using_logger 
     slsSupportShared
 )  
-
 set_target_properties(using_logger PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
 )
 
 
+add_executable(using_registers using_registers.cpp)
+target_link_libraries(using_registers 
+    slsDetectorShared
+)  
+set_target_properties(using_registers PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+)
+
+
 # add_executable(result useResult.cpp)
 # target_link_libraries(result 
 #     slsDetectorShared

sample/using_logger.cpp

@@ -3,14 +3,22 @@
 #include "sls/logger.h"
 #include <iostream>
 #include <chrono>
+
+using sls::logINFO;
+using sls::logINFORED;
+using sls::logINFOBLUE;
+using sls::logINFOGREEN;
+using sls::logERROR;
+using sls::logWARNING;
+
+
 int main() {
 
     //compare old and new
     std::cout << "Compare output between old and new:\n";
     LOG(logINFO) << "Some info message";
     LOG(logERROR) << "This is an error";
-    LOG(logWARNING) << "While this is only a warning";    prefix="/afs/psi.ch/project/sls_det_software/dhanya_softwareDevelopment/mySoft/slsDetectorPackage/"
-    p=${file#"$prefix"}
+    LOG(logWARNING) << "While this is only a warning";
     
     //Logging level can be configure at runtime
     std::cout << "\n\n";

sample/using_registers.cpp

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+
+/* This example assumes that you have a ctb configured or using the virtual ctb detector server*/
+
+#include "sls/Detector.h"
+#include "sls/bit_utils.h"
+#include <iostream>
+
+
+void somefunc(uint32_t addr){
+    std::cout << "somefunc called with: " << addr << std::endl;
+}
+
+int main(){
+
+    // Config file has the following defines
+    // define addr somereg 0x5
+    // define bit mybit somereg 7
+    
+    sls::Detector d;
+    auto somereg = d.getRegisterDefinition("somereg");
+    d.writeRegister(somereg, sls::RegisterValue(0));
+    auto val = d.readRegister(somereg);
+
+    std::cout << "somereg has the address: " << somereg <<  " and value " << val.squash() << std::endl;
+
+
+    auto mybit = d.getBitDefinition("mybit");
+    std::cout << "mybit refers to register: " << mybit.address() << " bit nr: " << mybit.bitPosition() << std::endl;
+    d.setBit(mybit);
+    val = d.readRegister(somereg);
+    std::cout << "somereg has the address: " << somereg <<  " and value " << val.squash() << std::endl;
+    std::cout << "mybit: " << d.getBit(mybit) << std::endl;
+
+
+    //Let's define a bit 
+    sls::BitAddress newbit(sls::RegisterAddress(0x6), 4);
+    d.setBitDefinition("newbit", newbit);
+    //This can now be usef from command line "g getbit newbit"
+
+
+
+
+    uint32_t addr = somereg; //I'm not sure this should compile
+    somefunc(somereg); //This should also not compile 
+
+    
+}

slsDetectorServers/slsDetectorServer/include/XILINX_FMC.h

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+
+int XILINX_FMC_enable_all(char* error_message, int message_size);
+int XILINX_FMC_disable_all(char* error_message, int message_size);

slsDetectorServers/slsDetectorServer/src/XILINX_FMC.c

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#include "XILINX_FMC.h"
+#include "arm64.h"
+#include "clogger.h"
+#include <math.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+// clang-format off
+#define FMC_BASE_PATH "/root/fmc/"
+#define FMC_VADJ_EN "FMC_VADJ_EN"
+#define FMCP_VADJ_EN "FMCP_VADJ_EN"
+#define FMCP_3V3_EN "FMCP_3V3_EN"
+#define FMC_3V3_EN "FMC_3V3_EN"
+#define FMC_12V_EN "FMC_12V_EN"
+#define FMCP_12V_EN "FMCP_12V_EN"
+
+static const char *fmc_files[] = {
+    FMC_VADJ_EN,
+    FMCP_VADJ_EN,
+    FMCP_3V3_EN,
+    FMC_3V3_EN,
+    FMC_12V_EN,
+    FMCP_12V_EN
+};
+#define FMC_NUM_FILES (sizeof(fmc_files) / sizeof(fmc_files[0]))
+// clang-format on
+
+int XILINX_FMC_enable_all(char* error_message, int message_size) {
+    LOG(logINFOBLUE, ("enable FMC power\n"));
+    #ifdef VIRTUAL
+        return;
+    #endif
+    char full_path[64];
+    for (size_t i = 0; i < FMC_NUM_FILES; ++i) {
+        const char* file = fmc_files[i];
+        snprintf(full_path, sizeof(full_path), "%s%s", FMC_BASE_PATH, file);
+        FILE *fp = fopen(full_path, "w");
+        if (fp == NULL) {
+            snprintf(error_message, message_size, "XILINX_FMC: Couuld not enable.\n");
+            LOG(logERROR, (error_message));
+            return 1;
+        }
+
+        if (fprintf(fp, "1\n") != 1) {
+            snprintf(error_message, message_size, "XILINX_FMC: Could not write enable.\n");
+            LOG(logERROR, (error_message));
+            return 1;
+        }
+        fclose(fp);
+    }
+    return 0;
+}
+
+int XILINX_FMC_disable_all(char* error_message, int message_size) {
+    LOG(logINFOBLUE, ("disable FMC power\n"));
+    #ifdef VIRTUAL
+        return;
+    #endif
+    char full_path[64];
+    for (size_t i = 0; i < FMC_NUM_FILES; ++i) {
+        const char* file = fmc_files[i];
+        snprintf(full_path, sizeof(full_path), "%s%s", FMC_BASE_PATH, file);
+        FILE *fp = fopen(full_path, "w");
+        if (fp == NULL) {
+            snprintf(error_message, message_size, "XILINX_FMC: Could not disable\n");
+            LOG(logERROR, (error_message));
+            return 1;
+        }
+        if (fprintf(fp, "0\n") != 1) {
+            snprintf(error_message, message_size, "XILINX_FMC: Could not write disable.\n");
+            LOG(logERROR, (error_message));
+            return 1;
+        }
+        fclose(fp);
+    }
+    return 0;
+}

slsDetectorServers/xilinx_ctbDetectorServer/CMakeLists.txt

@@ -7,6 +7,7 @@ add_executable(xilinx_ctbDetectorServer_virtual
     ../slsDetectorServer/src/communication_funcs.c
     ../slsDetectorServer/src/arm64.c
     ../slsDetectorServer/src/XILINX_PLL.c
+    ../slsDetectorServer/src/XILINX_FMC.c
     ../slsDetectorServer/src/common.c
     ../slsDetectorServer/src/sharedMemory.c
     ../slsDetectorServer/src/loadPattern.c

slsDetectorServers/xilinx_ctbDetectorServer/Makefile

@@ -23,7 +23,7 @@ DESTDIR		?= 	bin
 INSTMODE	= 	0777
 
 SRCS 		= 	slsDetectorFunctionList.c  
-SRCS		+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)arm64.c $(main_src)XILINX_PLL.c $(main_src)common.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c $(md5_dir)md5.c $(main_src)programViaArm.c $(main_src)LTC2620_Driver.c 
+SRCS		+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)arm64.c $(main_src)XILINX_PLL.c $(main_src)XILINX_FMC.c $(main_src)common.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c $(md5_dir)md5.c $(main_src)programViaArm.c $(main_src)LTC2620_Driver.c 
 
 OBJS 		= 	$(SRCS:.c=.o) 
  

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c

@@ -10,7 +10,7 @@
 
 #include "LTC2620_Driver.h"
 #include "XILINX_PLL.h"
-
+#include "XILINX_FMC.h"
 #include "loadPattern.h"
 #ifdef VIRTUAL
 #include "communication_funcs_UDP.h"
@@ -257,17 +257,17 @@ int testFixedFPGAPattern() {
     LOG(logINFO, ("Testing FPGA Fixed Pattern:\n"));
 #ifndef VIRTUAL
     uint32_t val = bus_r(FIXEDPATTERNREG);
-    if (val == FIXEDPATTERNVAL) {
+    if (val == FIXEDPATTERNREG_PRESET) {
         LOG(logINFO, ("\tFixed pattern: successful match (0x%08x)\n", val));
     } else {
         LOG(logERROR,
             ("Fixed pattern does not match! Read 0x%08x, expected 0x%08x\n",
-             val, FIXEDPATTERNVAL));
+             val, FIXEDPATTERNREG_PRESET));
         return FAIL;
     }
 #endif
     LOG(logINFO,
-        ("\tSuccessfully read FPGA Fixed Pattern (0x%x)\n", FIXEDPATTERNVAL));
+        ("\tSuccessfully read FPGA Fixed Pattern (0x%x)\n", FIXEDPATTERNREG_PRESET));
     return OK;
 }
 
@@ -405,6 +405,13 @@ void setupDetector() {
 
     LTC2620_D_SetDefines(DAC_MIN_MV, DAC_MAX_MV, DAC_DRIVER_FILE_NAME, NDAC,
                          NPWR, DAC_POWERDOWN_DRIVER_FILE_NAME);
+    
+    // power LTC2620 before talking to it:
+    initError = XILINX_FMC_enable_all(initErrorMessage, MAX_STR_LENGTH);
+    if (initError == FAIL) {
+        return;
+    }
+
     LOG(logINFOBLUE, ("Powering down all dacs\n"));
     for (int idac = 0; idac < NDAC; ++idac) {
         setDAC(idac, LTC2620_D_GetPowerDownValue(), 0);
@@ -579,9 +586,10 @@ int powerChip(int on, char *mess) {
     } else {
         LOG(logINFOBLUE, ("Powering chip: off\n"));
         bus_w(addr, bus_r(addr) & ~mask);
-
         chipConfigured = 0;
-
+        if (FAIL == XILINX_FMC_disable_all(mess, MAX_STR_LENGTH)) {
+            return FAIL;
+        }
 #ifdef VIRTUAL
         setTransceiverAlignment(0);
 #endif

slsDetectorSoftware/generator/Caller.in.h

@@ -74,6 +74,24 @@ class Caller {
     static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
                                   uint32_t subFrameIndex, void *this_pointer);
 
+    std::string bitoperations(int action);
+
+    // parsing from args
+    // parse from string to RegisterAddress
+    RegisterAddress parseRegisterAddress(const std::string &addr) const;
+    // parse from 2 strings to BitAddress
+    BitAddress parseBitAddress(const std::string &addr,
+                               const std::string &bitPos) const;
+    // parse from string to RegisterValue
+    RegisterValue parseRegisterValue(const std::string &addr) const;
+    // parse validate flag from args and remove it from args
+    bool parseValidate();
+
+    // parses from args, but also gets addresses from shared memory if
+    // applicable
+    RegisterAddress getRegisterAddress(const std::string &saddr) const;
+    BitAddress getBitAddress() const;
+
     FunctionMap functions{
         {"list", &Caller::list},
 

slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh

@@ -80,7 +80,7 @@ _sd() {
   local IS_PATH=0
 
 
-local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
+local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
 __acquire() {
 FCN_RETURN=""
 return 0
@@ -682,6 +682,54 @@ fi
 fi
 return 0
 }
+__define_bit() {
+FCN_RETURN=""
+if [[ ${IS_GET} -eq 1 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "3" ]]; then
+FCN_RETURN=""
+fi
+fi
+if [[ ${IS_GET} -eq 0 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "3" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "4" ]]; then
+FCN_RETURN=""
+fi
+fi
+return 0
+}
+__define_reg() {
+FCN_RETURN=""
+if [[ ${IS_GET} -eq 1 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+fi
+if [[ ${IS_GET} -eq 0 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "3" ]]; then
+FCN_RETURN=""
+fi
+fi
+return 0
+}
+__definelist_bit() {
+FCN_RETURN=""
+return 0
+}
+__definelist_reg() {
+FCN_RETURN=""
+return 0
+}
 __delay() {
 FCN_RETURN=""
 if [[ ${IS_GET} -eq 1 ]]; then

slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh

@@ -4,7 +4,7 @@
 _sd() {
 
 
-local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
+local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
 __acquire() {
 FCN_RETURN=""
 return 0
@@ -606,6 +606,54 @@ fi
 fi
 return 0
 }
+__define_bit() {
+FCN_RETURN=""
+if [[ ${IS_GET} -eq 1 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "3" ]]; then
+FCN_RETURN=""
+fi
+fi
+if [[ ${IS_GET} -eq 0 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "3" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "4" ]]; then
+FCN_RETURN=""
+fi
+fi
+return 0
+}
+__define_reg() {
+FCN_RETURN=""
+if [[ ${IS_GET} -eq 1 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+fi
+if [[ ${IS_GET} -eq 0 ]]; then
+if [[ "${cword}" == "2" ]]; then
+FCN_RETURN=""
+fi
+if [[ "${cword}" == "3" ]]; then
+FCN_RETURN=""
+fi
+fi
+return 0
+}
+__definelist_bit() {
+FCN_RETURN=""
+return 0
+}
+__definelist_reg() {
+FCN_RETURN=""
+return 0
+}
 __delay() {
 FCN_RETURN=""
 if [[ ${IS_GET} -eq 1 ]]; then

slsDetectorSoftware/generator/commands.yaml

@@ -2761,6 +2761,90 @@ sleep:
             - argc: 2
               arg_types: [ int, special::time_unit ]
 
+define_reg:
+    is_description: true
+    actions:
+        GET:
+          argc: 1
+          arg_types: [ std::string ]
+        PUT:
+          argc: 2
+          arg_types: [ std::string, int ]
+
+define_bit:
+    is_description: true
+    actions:
+        GET:
+          args:
+            - argc: 1
+              arg_types: [ std::string ]
+            - argc: 2
+              arg_types: [ std::string, int ]
+        PUT:
+          argc: 3
+          arg_types: [ std::string, std::string, int ]
+
+definelist_reg:
+    is_description: true
+    actions:
+        GET:
+          argc: 0
+
+definelist_bit:
+    is_description: true
+    actions:
+        GET:
+          argc: 0
+
+reg:
+    is_description: true
+    actions:
+        GET:
+          argc: 1
+          arg_types: [ std::string]
+        PUT:
+          args:
+            - argc: 2
+              arg_types: [ uint32_t, uint32_t ]
+            - argc: 3
+              arg_types: [ uint32_t, uint32_t, special::validate ]
+
+
+getbit:
+    is_description: true
+    actions:
+        GET:
+          args:
+            - argc: 1
+              arg_types: [ std::string ]
+            - argc: 2
+              arg_types: [ std::string, std::string ]
+
+
+setbit:
+    is_description: true
+    actions:
+        PUT:
+          args:
+            - argc: 1
+              arg_types: [ std::string ]
+            - argc: 2
+              arg_types: [ std::string, std::string ]
+            - argc: 3
+              arg_types: [ std::string, std::string, special::validate ]
+
+clearbit:
+    is_description: true
+    actions:
+        PUT:
+          args:
+            - argc: 1
+              arg_types: [ std::string ]
+            - argc: 2
+              arg_types: [ std::string, std::string ]
+            - argc: 3
+              arg_types: [ std::string, std::string, special::validate ]
+
 
 ################# special commands ##########################
 
@@ -4172,36 +4256,6 @@ update:
       input_types: [ std::string, std::string ]
       output: [ '"successful"' ]
 
-reg:
-  help: "[address] [32 bit value][(optional)--validate]\n\t[Mythen3][Gotthard2] Reads/writes to a 32 bit register in hex. Advanced Function!\n\tGoes to stop server. Hence, can be called while calling blocking acquire().\n\t\t Use --validate to force validation when writing to it.\n\t[Eiger] +0x100 for only left, +0x200 for only right."
-  actions:
-    GET:
-      argc: 1
-      require_det_id: true
-      function: readRegister
-      input: [ 'args[0]' ]
-      input_types: [ uint32_t ]
-      cast_input: [ true ]
-      output: [ OutStringHex(t) ]
-    PUT:
-      require_det_id: true
-      function: writeRegister
-      output: [ '"["', 'args[0]', '", "', 'args[1]', '"]"' ]
-      args:
-        - argc: 2
-          input: [ 'args[0]', 'args[1]', '"0"' ]
-          input_types: [ uint32_t, uint32_t, bool ]
-          arg_types: [ uint32_t, uint32_t ]
-          cast_input: [ true, true, true ]
-        - argc: 3
-          arg_types: [ uint32_t, uint32_t, special::validate ]
-          exceptions:
-            - condition: 'args[2] != "--validate"'
-              message: '"Could not scan third argument. Did you mean --validate?"'
-          input: [ 'args[0]', 'args[1]', '"1"' ]
-          input_types: [ uint32_t, uint32_t, bool ]
-          cast_input: [ true, true, true ]
-
 adcreg:
   help: "[address] [value]\n\t[Jungfrau][Moench][Ctb] Writes to an adc register in hex. Advanced user Function!"
   actions:
@@ -4214,62 +4268,7 @@ adcreg:
       cast_input: [ true, true ]
       output: [ ToString(args) ]
 
-getbit:
-  help: "[reg address in hex] [bit index]\n\tGets bit in address."
-  actions:
-    GET:
-      argc: 2
-      exceptions:
-        - condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
-          message: '"Bit number out of range: " + args[1]'
-      require_det_id: true
-      function: getBit
-      input: [ 'args[0]', 'args[1]' ]
-      input_types: [ uint32_t, int ]
-      cast_input: [ true, true ]
-      output: [ OutString(t) ]
 
-Setbit:
-  template: true
-  actions:
-    PUT:
-      require_det_id: true
-      function: setBit
-      output: [ '"["', 'args[0]', '", "', 'args[1]', '"]"' ]    
-      args:
-        - argc: 2
-          exceptions:
-            - condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
-              message: '"Bit number out of range: " + args[1]'
-          input: [ 'args[0]', 'args[1]', '"0"' ]  
-          input_types: [ uint32_t, int, bool ]
-          arg_types: [ uint32_t, int ]
-          cast_input: [ true, true, true ]
-        - argc: 3
-          arg_types: [ uint32_t, int, special::validate ]
-          exceptions:
-            - condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
-              message: '"Bit number out of range: " + args[1]'
-            - condition: 'args[2] != "--validate"'
-              message: '"Could not scan third argument. Did you mean --validate?"'
-          input: [ 'args[0]', 'args[1]', '"1"' ]
-          input_types: [ uint32_t, int, bool ]
-          cast_input: [ true, true, true ]
-
-
-setbit:
-  inherit_actions: Setbit
-  help: "[reg address in hex] [bit index]\n\tSets bit in address.\n\tUse --validate to force validation."
-  actions:
-    PUT:
-      function: setBit
-
-clearbit:
-  inherit_actions: Setbit
-  help: "[reg address in hex] [bit index]\n\tClears bit in address.\n\tUse --validate to force validation."
-  actions:
-    PUT:
-      function: clearBit
 
 initialchecks:
   help: "[0, 1]\n\t[Mythen3][Gotthard2] Enable or disable intial compatibility and other checks at detector start up. It is enabled by default. Must come before 'hostname' command to take effect. Can be used to reprogram fpga when current firmware is incompatible.\n\tAdvanced User function!"

slsDetectorSoftware/generator/extended_commands.yaml

@@ -1096,74 +1096,49 @@ clearbit:
     PUT:
       args:
       - arg_types:
-        - uint32_t
-        - int
-        argc: 2
-        cast_input:
-        - true
-        - true
-        - true
+        - std::string
+        argc: 1
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        exceptions:
-        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
-          message: '"Bit number out of range: " + args[1]'
-        function: clearBit
-        input:
-        - args[0]
-        - args[1]
-        - '"0"'
-        input_types:
-        - uint32_t
-        - int
-        - bool
-        output:
-        - '"["'
-        - args[0]
-        - '", "'
-        - args[1]
-        - '"]"'
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: false
       - arg_types:
-        - uint32_t
-        - int
-        - special::validate
-        argc: 3
-        cast_input:
-        - true
-        - true
-        - true
+        - std::string
+        - std::string
+        argc: 2
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        exceptions:
-        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
-          message: '"Bit number out of range: " + args[1]'
-        - condition: args[2] != "--validate"
-          message: '"Could not scan third argument. Did you mean --validate?"'
-        function: clearBit
-        input:
-        - args[0]
-        - args[1]
-        - '"1"'
-        input_types:
-        - uint32_t
-        - int
-        - bool
-        output:
-        - '"["'
-        - args[0]
-        - '", "'
-        - args[1]
-        - '"]"'
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: false
+      - arg_types:
+        - std::string
+        - std::string
+        - special::validate
+        argc: 3
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: false
   command_name: clearbit
   function_alias: clearbit
-  help: "[reg address in hex] [bit index]\n\tClears bit in address.\n\tUse --validate\
-    \ to force validation."
+  help: ''
   infer_action: true
-  template: true
+  is_description: true
 clearbusy:
   actions:
     PUT:
@@ -2500,6 +2475,132 @@ defaultpattern:
     \ to go back to initial settings."
   infer_action: true
   template: true
+define_bit:
+  actions:
+    GET:
+      args:
+      - arg_types:
+        - std::string
+        argc: 1
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: true
+      - arg_types:
+        - std::string
+        - int
+        argc: 2
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: true
+    PUT:
+      args:
+      - arg_types:
+        - std::string
+        - std::string
+        - int
+        argc: 3
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: false
+  command_name: define_bit
+  function_alias: define_bit
+  help: ''
+  infer_action: true
+  is_description: true
+define_reg:
+  actions:
+    GET:
+      args:
+      - arg_types:
+        - std::string
+        argc: 1
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: true
+    PUT:
+      args:
+      - arg_types:
+        - std::string
+        - int
+        argc: 2
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: false
+  command_name: define_reg
+  function_alias: define_reg
+  help: ''
+  infer_action: true
+  is_description: true
+definelist_bit:
+  actions:
+    GET:
+      args:
+      - arg_types: []
+        argc: 0
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: true
+  command_name: definelist_bit
+  function_alias: definelist_bit
+  help: ''
+  infer_action: true
+  is_description: true
+definelist_reg:
+  actions:
+    GET:
+      args:
+      - arg_types: []
+        argc: 0
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: true
+  command_name: definelist_reg
+  function_alias: definelist_reg
+  help: ''
+  infer_action: true
+  is_description: true
 delay:
   actions:
     GET:
@@ -4706,32 +4807,35 @@ getbit:
     GET:
       args:
       - arg_types:
-        - uint32_t
-        - int
-        argc: 2
-        cast_input:
-        - true
-        - true
+        - std::string
+        argc: 1
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        exceptions:
-        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
-          message: '"Bit number out of range: " + args[1]'
-        function: getBit
-        input:
-        - args[0]
-        - args[1]
-        input_types:
-        - uint32_t
-        - int
-        output:
-        - OutString(t)
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: true
+      - arg_types:
+        - std::string
+        - std::string
+        argc: 2
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: true
   command_name: getbit
   function_alias: getbit
-  help: "[reg address in hex] [bit index]\n\tGets bit in address."
+  help: ''
   infer_action: true
+  is_description: true
 hardwareversion:
   actions:
     GET:
@@ -7870,20 +7974,16 @@ reg:
     GET:
       args:
       - arg_types:
-        - uint32_t
+        - std::string
         argc: 1
-        cast_input:
-        - true
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        function: readRegister
-        input:
-        - args[0]
-        input_types:
-        - uint32_t
-        output:
-        - OutStringHex(t)
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: true
     PUT:
       args:
@@ -7891,68 +7991,34 @@ reg:
         - uint32_t
         - uint32_t
         argc: 2
-        cast_input:
-        - true
-        - true
-        - true
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        function: writeRegister
-        input:
-        - args[0]
-        - args[1]
-        - '"0"'
-        input_types:
-        - uint32_t
-        - uint32_t
-        - bool
-        output:
-        - '"["'
-        - args[0]
-        - '", "'
-        - args[1]
-        - '"]"'
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: false
       - arg_types:
         - uint32_t
         - uint32_t
         - special::validate
         argc: 3
-        cast_input:
-        - true
-        - true
-        - true
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        exceptions:
-        - condition: args[2] != "--validate"
-          message: '"Could not scan third argument. Did you mean --validate?"'
-        function: writeRegister
-        input:
-        - args[0]
-        - args[1]
-        - '"1"'
-        input_types:
-        - uint32_t
-        - uint32_t
-        - bool
-        output:
-        - '"["'
-        - args[0]
-        - '", "'
-        - args[1]
-        - '"]"'
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: false
   command_name: reg
   function_alias: reg
-  help: "[address] [32 bit value][(optional)--validate]\n\t[Mythen3][Gotthard2] Reads/writes\
-    \ to a 32 bit register in hex. Advanced Function!\n\tGoes to stop server. Hence,\
-    \ can be called while calling blocking acquire().\n\t\t Use --validate to force\
-    \ validation when writing to it.\n\t[Eiger] +0x100 for only left, +0x200 for only\
-    \ right."
+  help: ''
   infer_action: true
+  is_description: true
 resetdacs:
   actions:
     PUT:
@@ -9577,74 +9643,49 @@ setbit:
     PUT:
       args:
       - arg_types:
-        - uint32_t
-        - int
-        argc: 2
-        cast_input:
-        - true
-        - true
-        - true
+        - std::string
+        argc: 1
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        exceptions:
-        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
-          message: '"Bit number out of range: " + args[1]'
-        function: setBit
-        input:
-        - args[0]
-        - args[1]
-        - '"0"'
-        input_types:
-        - uint32_t
-        - int
-        - bool
-        output:
-        - '"["'
-        - args[0]
-        - '", "'
-        - args[1]
-        - '"]"'
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: false
       - arg_types:
-        - uint32_t
-        - int
-        - special::validate
-        argc: 3
-        cast_input:
-        - true
-        - true
-        - true
+        - std::string
+        - std::string
+        argc: 2
+        cast_input: []
         check_det_id: false
         convert_det_id: true
-        exceptions:
-        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
-          message: '"Bit number out of range: " + args[1]'
-        - condition: args[2] != "--validate"
-          message: '"Could not scan third argument. Did you mean --validate?"'
-        function: setBit
-        input:
-        - args[0]
-        - args[1]
-        - '"1"'
-        input_types:
-        - uint32_t
-        - int
-        - bool
-        output:
-        - '"["'
-        - args[0]
-        - '", "'
-        - args[1]
-        - '"]"'
-        require_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
+        store_result_in_t: false
+      - arg_types:
+        - std::string
+        - std::string
+        - special::validate
+        argc: 3
+        cast_input: []
+        check_det_id: false
+        convert_det_id: true
+        function: ''
+        input: []
+        input_types: []
+        output: []
+        require_det_id: false
         store_result_in_t: false
   command_name: setbit
   function_alias: setbit
-  help: "[reg address in hex] [bit index]\n\tSets bit in address.\n\tUse --validate\
-    \ to force validation."
+  help: ''
   infer_action: true
-  template: true
+  is_description: true
 settings:
   actions:
     GET:

slsDetectorSoftware/include/sls/Detector.h

@@ -3,6 +3,7 @@
 #pragma once
 #include "sls/Pattern.h"
 #include "sls/Result.h"
+#include "sls/bit_utils.h"
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
 #include <chrono>
@@ -1837,6 +1838,64 @@ class Detector {
     /** [CTB][Xilinx CTB] */
     std::string getSlowADCName(const defs::dacIndex i) const;
 
+    /** [CTB][Xilinx CTB] */
+    int getRegisterDefinitionsCount() const;
+
+    /** [CTB][Xilinx CTB] */
+    void setRegisterDefinition(const std::string &name, RegisterAddress addr);
+
+    /** [CTB][Xilinx CTB] */
+    bool hasRegisterDefinition(const std::string &name) const;
+
+    /** [CTB][Xilinx CTB] */
+    bool hasRegisterDefinition(RegisterAddress addr) const;
+
+    /** [CTB][Xilinx CTB] */
+    RegisterAddress getRegisterAddress(const std::string &name) const;
+
+    /** [CTB][Xilinx CTB] */
+    std::string getRegisterName(RegisterAddress addr) const;
+
+    /** [CTB][Xilinx CTB] */
+    void clearRegisterDefinitions();
+
+    /** [CTB][Xilinx CTB] */
+    void
+    setRegisterDefinitions(const std::map<std::string, RegisterAddress> &list);
+
+    /** [CTB][Xilinx CTB] */
+    std::map<std::string, RegisterAddress> getRegisterDefinitions() const;
+
+    /** [CTB][Xilinx CTB] */
+    int getBitDefinitionsCount() const;
+
+    /** [CTB][Xilinx CTB] */
+    void setBitDefinition(const std::string &name, BitAddress addr);
+
+    /** [CTB][Xilinx CTB] */
+    bool hasBitDefinition(const std::string &name) const;
+
+    /** [CTB][Xilinx CTB] */
+    bool hasBitDefinition(BitAddress addr) const;
+
+    /** [CTB][Xilinx CTB] */
+    std::string toRegisterNameBitString(BitAddress addr) const;
+
+    /** [CTB][Xilinx CTB] returns bit position and address */
+    BitAddress getBitAddress(const std::string &name) const;
+
+    /** [CTB][Xilinx CTB] */
+    std::string getBitName(BitAddress addr) const;
+
+    /** [CTB][Xilinx CTB] */
+    void clearBitDefinitions();
+
+    /** [CTB][Xilinx CTB] */
+    void setBitDefinitions(const std::map<std::string, BitAddress> &list);
+
+    /** [CTB][Xilinx CTB] */
+    std::map<std::string, BitAddress> getBitDefinitions() const;
+
     ///@}
 
     /** @name Xilinx CTB Specific */
@@ -2045,26 +2104,71 @@ class Detector {
     /** Advanced user Function! \n
      * Goes to stop server. Hence, can be called while calling blocking
      * acquire(). \n [Eiger] Address is +0x100 for only left, +0x200 for only
-     * right. */
-    Result<uint32_t> readRegister(uint32_t addr, Positions pos = {}) const;
+     * right.*/
+    Result<RegisterValue> readRegister(RegisterAddress addr,
+                                       Positions pos = {}) const;
 
     /** Advanced user Function! \n
      * Goes to stop server. Hence, can be called while calling blocking
      * acquire(). \n [Eiger] Address is +0x100 for only left, +0x200 for only
-     * right. */
-    void writeRegister(uint32_t addr, uint32_t val, bool validate = false,
-                       Positions pos = {});
+     * right.*/
+    void writeRegister(RegisterAddress addr, RegisterValue val,
+                       bool validate = false, Positions pos = {});
 
     /** Advanced user Function! */
-    void setBit(uint32_t addr, int bitnr, bool validate = false,
-                Positions pos = {});
+    void setBit(BitAddress addr, bool validate = false, Positions pos = {});
+
+    /** Advanced user Function!*/
+    void clearBit(BitAddress addr, bool validate = false, Positions pos = {});
 
     /** Advanced user Function! */
-    void clearBit(uint32_t addr, int bitnr, bool validate = false,
+    Result<int> getBit(BitAddress addr, Positions pos = {}) const;
+
+    /** [CTB][Xilinx CTB] Advanced user Function! */
+    Result<RegisterValue> readRegister(const std::string &reg_name,
+                                       Positions pos = {}) const;
+
+    /** [CTB][Xilinx CTB] Advanced user Function! */
+    void writeRegister(const std::string &reg_name, RegisterValue val,
+                       bool validate = false, Positions pos = {});
+
+    /** [CTB][Xilinx CTB] Advanced user Function! */
+    void setBit(const std::string &bit_name, bool validate = false,
                 Positions pos = {});
 
-    /** Advanced user Function!  */
-    Result<int> getBit(uint32_t addr, int bitnr, Positions pos = {});
+    /** [CTB][Xilinx CTB] Advanced user Function! */
+    void clearBit(const std::string &bit_name, bool validate = false,
+                  Positions pos = {});
+
+    /** [CTB][Xilinx CTB] Advanced user Function! */
+    Result<int> getBit(const std::string &bit_name, Positions pos = {}) const;
+
+    /** Deprecated Advanced user Function! */
+    [[deprecated("Use the overload taking RegisterAddress instead of "
+                 "uint32_t")]] Result<uint32_t>
+    readRegister(uint32_t addr, Positions pos = {}) const;
+
+    /** Deprecated Advanced user Function! */
+    [[deprecated("Use the overload taking RegisterAddress and RegisterValue "
+                 "instead of uint32_t")]] void
+    writeRegister(uint32_t addr, uint32_t val, bool validate = false,
+                  Positions pos = {});
+
+    /** Deprecated Advanced user Function! */
+    [[deprecated("Use the overload taking BitAddress instead of uint32_t and "
+                 "int")]] void
+    setBit(uint32_t addr, int bitnr, bool validate = false, Positions pos = {});
+
+    /** Deprecated Advanced user Function! */
+    [[deprecated("Use the overload taking BitAddress instead of uint32_t and "
+                 "int")]] void
+    clearBit(uint32_t addr, int bitnr, bool validate = false,
+             Positions pos = {});
+
+    /** Deprecated Advanced user Function! */
+    [[deprecated("Use the overload taking BitAddress instead of uint32_t and "
+                 "int")]] Result<int>
+    getBit(uint32_t addr, int bitnr, Positions pos = {}) const;
 
     /** [Jungfrau][Moench][Mythen3][Gotthard2][CTB] Advanced user
      * Function! */

slsDetectorSoftware/include/sls/detectorData.h

@@ -25,21 +25,21 @@ class detectorData {
     ~detectorData(){};
 
     int64_t getChannel(int i) {
-        const int off = dynamicRange / 8;
+        int off = dynamicRange / 8;
         if (off == 1) {
-            const char val = *(data + i);
+            char val = *(data + i);
             return val;
         }
         if (off == 2) {
-            const int16_t val = *((int16_t *)(data + i * off));
+            int16_t val = *((int16_t *)(data + i * off));
             return val;
         }
         if (off == 4) {
-            const int32_t val = *((int32_t *)(data + i * off));
+            int32_t val = *((int32_t *)(data + i * off));
             return val;
         }
         if (off == 8) {
-            const int64_t val = *((int64_t *)(data + i * off));
+            int64_t val = *((int64_t *)(data + i * off));
             return val;
         }
         return -1;

slsDetectorSoftware/src/Caller.h

@@ -107,6 +107,10 @@ class Caller {
     std::string dbitpipeline(int action);
     std::string defaultdac(int action);
     std::string defaultpattern(int action);
+    std::string define_bit(int action);
+    std::string define_reg(int action);
+    std::string definelist_bit(int action);
+    std::string definelist_reg(int action);
     std::string delay(int action);
     std::string delayl(int action);
     std::string detectorserverversion(int action);
@@ -398,6 +402,24 @@ class Caller {
     static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
                                   uint32_t subFrameIndex, void *this_pointer);
 
+    std::string bitoperations(int action);
+
+    // parsing from args
+    // parse from string to RegisterAddress
+    RegisterAddress parseRegisterAddress(const std::string &addr) const;
+    // parse from 2 strings to BitAddress
+    BitAddress parseBitAddress(const std::string &addr,
+                               const std::string &bitPos) const;
+    // parse from string to RegisterValue
+    RegisterValue parseRegisterValue(const std::string &addr) const;
+    // parse validate flag from args and remove it from args
+    bool parseValidate();
+
+    // parses from args, but also gets addresses from shared memory if
+    // applicable
+    RegisterAddress getRegisterAddress(const std::string &saddr) const;
+    BitAddress getBitAddress() const;
+
     FunctionMap functions{
         {"list", &Caller::list},
 
@@ -451,6 +473,10 @@ class Caller {
         {"dbitpipeline", &Caller::dbitpipeline},
         {"defaultdac", &Caller::defaultdac},
         {"defaultpattern", &Caller::defaultpattern},
+        {"define_bit", &Caller::define_bit},
+        {"define_reg", &Caller::define_reg},
+        {"definelist_bit", &Caller::definelist_bit},
+        {"definelist_reg", &Caller::definelist_reg},
         {"delay", &Caller::delay},
         {"delayl", &Caller::delayl},
         {"detectorserverversion", &Caller::detectorserverversion},

slsDetectorSoftware/src/CallerSpecial.cpp

@@ -102,7 +102,7 @@ std::string Caller::list(int action) {
 /* Network Configuration (Detector<->Receiver) */
 
 IpAddr Caller::getDstIpFromAuto() {
-    std::string const rxHostname =
+    std::string rxHostname =
         det->getRxHostname(std::vector<int>{det_id}).squash("none");
     // Hostname could be ip try to decode otherwise look up the hostname
     auto val = IpAddr{rxHostname};
@@ -113,7 +113,7 @@ IpAddr Caller::getDstIpFromAuto() {
 }
 
 IpAddr Caller::getSrcIpFromAuto() {
-    std::string const hostname =
+    std::string hostname =
         det->getHostname(std::vector<int>{det_id}).squash("none");
     // Hostname could be ip try to decode otherwise look up the hostname
     auto val = IpAddr{hostname};
@@ -128,9 +128,9 @@ UdpDestination Caller::getUdpEntry() {
     udpDestination.entry = rx_id;
 
     for (auto it : args) {
-        size_t const pos = it.find('=');
-        std::string const key = it.substr(0, pos);
-        std::string const value = it.substr(pos + 1);
+        size_t pos = it.find('=');
+        std::string key = it.substr(0, pos);
+        std::string value = it.substr(pos + 1);
         if (key == "ip") {
             if (value == "auto") {
                 auto val = getDstIpFromAuto();
@@ -177,7 +177,7 @@ int Caller::GetLevelAndInsertIntoArgs(std::string levelSeparatedCommand) {
         LOG(logWARNING) << "This command is deprecated and will be removed. "
                            "Please migrate to "
                         << levelSeparatedCommand;
-        int const level = cmd[cmd.find_first_of("012")] - '0';
+        int level = cmd[cmd.find_first_of("012")] - '0';
         args.insert(args.begin(), std::to_string(level));
         return true;
     }
@@ -295,8 +295,8 @@ std::string Caller::versions(int action) {
         bool receiver = false;
         std::string vReceiver = "Unknown";
 
-        std::string const vRelease = det->getPackageVersion();
-        std::string const vClient = det->getClientVersion();
+        std::string vRelease = det->getPackageVersion();
+        std::string vClient = det->getClientVersion();
 
         if (det->size() != 0) {
             // shared memory has detectors
@@ -382,7 +382,7 @@ std::string Caller::threshold(int action) {
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
-        defs::detectorType const type = det->getDetectorType().squash();
+        defs::detectorType type = det->getDetectorType().squash();
         if (type == defs::EIGER) {
             auto t = det->getThresholdEnergy(std::vector<int>{det_id});
             os << OutString(t) << '\n';
@@ -393,7 +393,7 @@ std::string Caller::threshold(int action) {
             throw RuntimeError("Not implemented for this detector\n");
         }
     } else if (action == defs::PUT_ACTION) {
-        defs::detectorType const type = det->getDetectorType().squash();
+        defs::detectorType type = det->getDetectorType().squash();
         if (type == defs::EIGER && args.size() != 1 && args.size() != 2) {
             WrongNumberOfParameters(1);
         }
@@ -401,7 +401,7 @@ std::string Caller::threshold(int action) {
             WrongNumberOfParameters(1);
         }
 
-        bool const trimbits = (cmd == "thresholdnotb") ? false : true;
+        bool trimbits = (cmd == "thresholdnotb") ? false : true;
         std::array<int, 3> energy = {StringTo<int>(args[0]), 0, 0};
         energy[1] = energy[0];
         energy[2] = energy[0];
@@ -708,7 +708,7 @@ std::string Caller::rx_hostname(int action) {
     return os.str();
 }
 std::string Caller::rx_zmqip(int action) {
-    std::string const helpMessage =
+    std::string helpMessage =
         "\n\t[deprecated] The receiver zmq socket (publisher) will "
         "listen to all interfaces ('tcp://0.0.0.0:[port]'to all interfaces "
         "(from v9.0.0). This command does nothing and will be removed "
@@ -729,7 +729,7 @@ std::string Caller::rx_zmqip(int action) {
 
 std::string Caller::rx_roi(int action) {
     std::ostringstream os;
-    std::string const helpMessage =
+    std::string helpMessage =
         std::string("[xmin] [xmax] [ymin] [ymax]\n") +
         "\tDefines a single region of interest (ROI) in the receiver.\n"
         "\tFor example, to set a single ROI: 0 100 20 30\n\n"
@@ -771,7 +771,7 @@ std::string Caller::rx_roi(int action) {
         }
         // Support multiple args with bracketed ROIs, or single arg with
         // semicolon-separated vector in quotes
-        bool const isVectorInput =
+        bool isVectorInput =
             std::all_of(args.begin(), args.end(), [](const std::string &a) {
                 return a.find('[') != std::string::npos &&
                        a.find(']') != std::string::npos;
@@ -870,7 +870,7 @@ std::string Caller::ratecorr(int action) {
         if (args.size() != 1) {
             WrongNumberOfParameters(1);
         }
-        int const tau = StringTo<int>(args[0]);
+        int tau = StringTo<int>(args[0]);
         if (tau == -1) {
             det->setDefaultRateCorrection(std::vector<int>{det_id});
             auto t = det->getRateCorrection(std::vector<int>{det_id});
@@ -905,7 +905,7 @@ std::string Caller::burstmode(int action) {
             }
             defs::burstMode t;
             try {
-                int const ival = StringTo<int>(args[0]);
+                int ival = StringTo<int>(args[0]);
                 switch (ival) {
                 case 0:
                     t = defs::BURST_INTERNAL;
@@ -1001,7 +1001,7 @@ std::string Caller::counters(int action) {
         // convert vector to counter enable mask
         uint32_t mask = 0;
         for (size_t i = 0; i < args.size(); ++i) {
-            int const val = StringTo<int>(args[i]);
+            int val = StringTo<int>(args[i]);
             // already enabled earlier
             if (mask & (1 << val)) {
                 std::ostringstream oss;
@@ -1036,9 +1036,9 @@ std::string Caller::samples(int action) {
             auto d = det->getNumberOfDigitalSamples(std::vector<int>{det_id});
             auto t =
                 det->getNumberOfTransceiverSamples(std::vector<int>{det_id});
-            int const as = a.squash(-1);
-            int const ds = d.squash(-1);
-            int const ts = t.squash(-1);
+            int as = a.squash(-1);
+            int ds = d.squash(-1);
+            int ts = t.squash(-1);
             if (as == -1 || ds == -1 || ts == -1 || as != ds ||
                 as != ts) { // check if a == d?
                 throw RuntimeError(
@@ -1077,7 +1077,7 @@ std::string Caller::slowadc(int action) {
         if (args.size() != 1) {
             WrongNumberOfParameters(0);
         }
-        int const nchan = StringTo<int>(args[0]);
+        int nchan = StringTo<int>(args[0]);
         if (nchan < 0 || nchan > 7) {
             throw RuntimeError("Unknown adc argument " + args[0]);
         }
@@ -1109,7 +1109,7 @@ std::string Caller::patwaittime(int action) {
     }
 
     // parse level
-    bool const deprecated_cmd = GetLevelAndInsertIntoArgs("patwaittime");
+    bool deprecated_cmd = GetLevelAndInsertIntoArgs("patwaittime");
     int level = 0;
     try {
         if (args.size() > 0)
@@ -1141,7 +1141,7 @@ std::string Caller::patwaittime(int action) {
         // clocks (all digits)
         if (args.size() == 2 &&
             std::all_of(args[1].begin(), args[1].end(), ::isdigit)) {
-            uint64_t const waittime = StringTo<uint64_t>(args[1]);
+            uint64_t waittime = StringTo<uint64_t>(args[1]);
             det->setPatternWaitClocks(level, waittime,
                                       std::vector<int>{det_id});
             os << waittime << '\n';
@@ -1152,7 +1152,7 @@ std::string Caller::patwaittime(int action) {
             try {
                 if (args.size() == 2) {
                     std::string tmp_time(args[1]);
-                    std::string const unit = RemoveUnit(tmp_time);
+                    std::string unit = RemoveUnit(tmp_time);
                     converted_time = StringTo<time::ns>(tmp_time, unit);
                 } else {
                     converted_time = StringTo<time::ns>(args[1], args[2]);
@@ -1205,7 +1205,7 @@ std::string Caller::rx_dbitlist(int action) {
         }
         // 'none' option already covered as t is empty by default
         else if (args[0] != "none") {
-            unsigned int const ntrim = args.size();
+            unsigned int ntrim = args.size();
             t.resize(ntrim);
             for (unsigned int i = 0; i < ntrim; ++i) {
                 t[i] = StringTo<int>(args[i]);
@@ -1421,7 +1421,7 @@ std::string Caller::sleep(int action) {
         try {
             if (args.size() == 1) {
                 std::string tmp_time(args[0]);
-                std::string const unit = RemoveUnit(tmp_time);
+                std::string unit = RemoveUnit(tmp_time);
                 converted_time = StringTo<time::ns>(tmp_time, unit);
             } else {
                 converted_time = StringTo<time::ns>(args[0], args[1]);
@@ -1437,4 +1437,365 @@ std::string Caller::sleep(int action) {
     return os.str();
 }
 
+std::string Caller::define_reg(int action) {
+    std::ostringstream os;
+    if (action == defs::HELP_ACTION) {
+        os << "[Ctb][Xilinx Ctb]"
+              "\n\t[reg name] [reg address]"
+              "\n\n\tSets a user defined register in shared memory. The name "
+              "can be upto 32 characters long."
+              "\n\teg."
+              "\n\tsls_detector_put define_reg test_reg 0x200"
+              "\n\n\tOne can retrieve the address using the name and vice "
+              "versa."
+              "\n\teg."
+              "\n\tsls_detector_get define_reg test_reg"
+              "\n\tsls_detector_get define_reg 0x200"
+              "\n\n\tOne can then use this user-defined name in other commands "
+              "instead of hard coding the address such as for reg, setbit, "
+              "clearbit and getbit commands."
+              "\n\teg."
+              "\n\tsls_detector_put reg test_reg 0x1"
+              "\n\tsls_detector_put setbit test_reg 2"
+              "\n\tsls_detector_put clearbit test_reg 2"
+              "\n\tsls_detector_get getbit test_reg 2"
+           << '\n';
+        return os.str();
+    }
+    if (det_id != -1) {
+        throw RuntimeError("Cannot use define at module level. Use the default "
+                           "multi-module level");
+    }
+    if (action == defs::GET_ACTION) {
+        if (args.size() != 1) {
+            WrongNumberOfParameters(1);
+        }
+        // get name from address
+        if (is_hex_or_dec_uint(args[0])) {
+            auto addr = parseRegisterAddress(args[0]);
+            auto t = det->getRegisterName(addr);
+            os << t << '\n';
+        }
+        // get address from name
+        else {
+            auto t = det->getRegisterAddress(args[0]);
+            os << t.str() << '\n';
+        }
+    } else if (action == defs::PUT_ACTION) {
+        if (args.size() != 2) {
+            WrongNumberOfParameters(2);
+        }
+        auto name = args[0];
+        auto addr = parseRegisterAddress(args[1]);
+        det->setRegisterDefinition(name, addr);
+        os << "addr " << name << ' ' << addr.str() << '\n';
+    } else {
+        throw RuntimeError("Unknown action");
+    }
+
+    return os.str();
+}
+
+std::string Caller::define_bit(int action) {
+    std::ostringstream os;
+    if (action == defs::HELP_ACTION) {
+        os << "[Ctb][Xilinx Ctb]"
+              "\n\t[bit name] [regiser name/address] [bit position]"
+              "\n\n\tSets a user defined bit name in shared memory "
+              "representing the register address and the bit position. The "
+              "address can be named prior using define_reg command. The name "
+              "can be upto 32 characters long."
+              "\n\teg."
+              "\n\tsls_detector_put define_bit test_bit test_reg 2"
+              "\n\tsls_detector_put define_bit test_bit 0x200 2"
+              "\n\n\tOne can retrieve the bit address using the name and vice "
+              "versa using both register name or address and bit position."
+              "\n\teg."
+              "\n\tsls_detector_get define_bit test_bit"
+              "\n\tsls_detector_get define_bit test_reg 2"
+              "\n\tsls_detector_get define_bit 0x200 2"
+              "\n\n\tOne can then use this user-defined name in other commands "
+              "such as for setbit, clearbit and getbit commands. When using "
+              "bit names, please dont use register name or address as bit name "
+              "is already tied to a specific register."
+              "\n\teg."
+              "\n\tsls_detector_put setbit test_bit"
+              "\n\tsls_detector_put clearbit test_bit"
+              "\n\tsls_detector_get getbit test_bit"
+           << '\n';
+        return os.str();
+    }
+    if (det_id != -1) {
+        throw RuntimeError("Cannot use define at module level. Use the default "
+                           "multi-module level");
+    }
+    if (action == defs::GET_ACTION) {
+        // get position from name
+        if (args.size() == 1) {
+            auto t = det->getBitAddress(args[0]);
+            os << det->toRegisterNameBitString(t) << '\n';
+        }
+        // get name from position and address
+        else if (args.size() == 2) {
+            auto addr = parseBitAddress(args[0], args[1]);
+            auto t = det->getBitName(addr);
+            os << t << '\n';
+
+        } else {
+            WrongNumberOfParameters(1);
+        }
+    } else if (action == defs::PUT_ACTION) {
+        if (args.size() != 3) {
+            WrongNumberOfParameters(3);
+        }
+        if (!is_int(args[2])) {
+            throw RuntimeError("Bit position must be an integer value.");
+        }
+        auto name = args[0];
+        auto addr = parseBitAddress(args[1], args[2]);
+        det->setBitDefinition(name, addr);
+        os << ToString(args) << '\n';
+    } else {
+        throw RuntimeError("Unknown action");
+    }
+
+    return os.str();
+}
+
+std::string Caller::definelist_reg(int action) {
+    std::ostringstream os;
+    if (action == defs::HELP_ACTION) {
+        os << "List of user-defined register definitions in shared memory."
+           << '\n';
+    } else if (action == defs::PUT_ACTION) {
+        throw RuntimeError("cannot put");
+    } else if (action == defs::GET_ACTION) {
+        if (!args.empty()) {
+            WrongNumberOfParameters(0);
+        }
+        auto t = det->getRegisterDefinitions();
+        os << '\n' << ToString(t) << '\n';
+    } else {
+        throw RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
+std::string Caller::definelist_bit(int action) {
+    std::ostringstream os;
+    if (action == defs::HELP_ACTION) {
+        os << "List of user-defined bit definitions in shared memory." << '\n';
+    } else if (action == defs::PUT_ACTION) {
+        throw RuntimeError("cannot put");
+    } else if (action == defs::GET_ACTION) {
+        if (!args.empty()) {
+            WrongNumberOfParameters(0);
+        }
+        auto t = det->getBitDefinitions();
+        os << "\n[";
+        for (const auto &[key, val] : t) {
+            os << key << ": ";
+            os << det->toRegisterNameBitString(val);
+            if (&key != &t.rbegin()->first) {
+                os << ", ";
+            }
+            os << '\n';
+        }
+        os << "]\n";
+    } else {
+        throw RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
+std::string Caller::reg(int action) {
+    std::ostringstream os;
+    if (action == defs::HELP_ACTION) {
+        os << "[address] [32 bit value][(optional)--validate]"
+              "\n\tReads/writes to a 32 bit register in hex."
+              "\n\tAdvanced Function!\n\tGoes to stop server. Hence, can be "
+              "called while calling blocking acquire()."
+              "\n\t\t Use --validate to enforce validation when writing to "
+              "register."
+              "\n\t[Eiger] +0x100 for only left, +0x200 for only right."
+              "\n\t[Ctb][Xilinx_Ctb] Address can also be a user-defined name "
+              "that was set previously using the define command."
+              "\n\t\teg."
+              "\n\t\tsls_detector_put reg 0x200 0xFFF --validate"
+              "\n\t\tsls_detector_get reg test_reg"
+              "\n\t\tsls_detector_put reg test_reg 0xFF"
+           << '\n';
+    } else {
+        if (action == defs::PUT_ACTION) {
+            if (args.size() < 2 || args.size() > 3) {
+                WrongNumberOfParameters(2);
+            }
+            auto validate = parseValidate();
+            auto addr = getRegisterAddress(args[0]);
+            auto val = parseRegisterValue(args[1]);
+            det->writeRegister(addr, val, validate, std::vector<int>{det_id});
+            os << addr.str() << " " << val.str() << '\n';
+        } else if (action == defs::GET_ACTION) {
+            if (args.size() != 1) {
+                WrongNumberOfParameters(1);
+            }
+            auto addr = getRegisterAddress(args[0]);
+            auto t = det->readRegister(addr, std::vector<int>{det_id});
+            os << OutString(t) << '\n';
+        } else {
+            throw RuntimeError("Unknown action");
+        }
+    }
+    return os.str();
+}
+
+std::string Caller::getbit(int action) { return bitoperations(action); }
+
+std::string Caller::setbit(int action) { return bitoperations(action); }
+
+std::string Caller::clearbit(int action) { return bitoperations(action); }
+
+std::string Caller::bitoperations(int action) {
+    std::ostringstream os;
+    if (action == defs::HELP_ACTION) {
+        if (cmd == "getbit") {
+            os << "[reg address in hex] [bit index]\n\tGets bit in address."
+               << '\n';
+        } else if (cmd == "setbit") {
+            os << "[reg address in hex] [bit index]\n\tSets bit in "
+                  "address.\n\tUse --validate to force validation."
+               << '\n';
+        } else if (cmd == "clearbit") {
+            os << "[reg address in hex] [bit index]\n\tClears bit in "
+                  "address.\n\tUse --validate to force validation."
+               << '\n';
+        } else {
+            throw RuntimeError("Unknown command");
+        }
+        os << "\n\t\t[Ctb][Xilinx_Ctb] Address or bit position can also be a "
+              "user-defined name that was set previously using the define "
+              "command. When using bit names, avoid register name/ address as "
+              "the bit name is tied to a specific register already."
+              "\n\n\teg."
+              "\n\tsls_detector_get getbit 0x200 2"
+              "\n\tsls_detector_get getbit test_reg 2"
+              "\n\tsls_detector_get getbit test_bit"
+              "\n\tsls_detector_put setbit 0x200 2"
+              "\n\tsls_detector_put setbit test_reg 2"
+              "\n\tsls_detector_put setbit test_bit"
+              "\n\tsls_detector_put clearbit test_bit";
+        os << '\n';
+    } else {
+        if (action != defs::GET_ACTION && action != defs::PUT_ACTION) {
+            throw RuntimeError("Unknown action");
+        }
+
+        auto validate = parseValidate();
+        auto addr = getBitAddress();
+        if (action == defs::GET_ACTION) {
+            if (cmd == "setbit" || cmd == "clearbit")
+                throw RuntimeError("Cannot get");
+
+            auto t = det->getBit(addr, std::vector<int>{det_id});
+            os << OutString(t) << '\n';
+        } else {
+            if (cmd == "getbit")
+                throw RuntimeError("Cannot put");
+            if (cmd == "setbit")
+                det->setBit(addr, validate, std::vector<int>{det_id});
+            else if (cmd == "clearbit")
+                det->clearBit(addr, validate, std::vector<int>{det_id});
+            else
+                throw RuntimeError("Unknown command");
+            os << ToString(args) << "\n";
+        }
+    }
+    return os.str();
+}
+
+RegisterAddress Caller::parseRegisterAddress(const std::string &addr) const {
+    try {
+        return RegisterAddress(StringTo<uint32_t>(addr));
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not parse register address " + addr +
+                           ". Must be an integer value");
+    }
+}
+
+BitAddress Caller::parseBitAddress(const std::string &addr,
+                                   const std::string &bitPos) const {
+    auto address = getRegisterAddress(addr);
+    uint32_t bitPosition = 0;
+
+    // parse bit position
+    if (!is_hex_or_dec_uint(bitPos)) {
+        throw RuntimeError("Bit position must be an integer value.");
+    }
+    try {
+        bitPosition = StringTo<uint32_t>(bitPos);
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not parse bit position " + bitPos +
+                           ". Must be an integer value");
+    }
+    return BitAddress(address, bitPosition);
+}
+
+RegisterValue Caller::parseRegisterValue(const std::string &addr) const {
+    try {
+        return RegisterValue(StringTo<uint32_t>(addr));
+    } catch (const std::exception &e) {
+        throw RuntimeError("Could not parse register value " + addr +
+                           ". Must be an integer value");
+    }
+}
+
+bool Caller::parseValidate() {
+    auto it = std::find(args.begin(), args.end(), "--validate");
+    bool validate = (it != args.end());
+
+    // invalid argument (--options), throw
+    if (!validate) {
+        auto invalid_it =
+            std::find_if(args.begin(), args.end(), [](const auto &s) {
+                // only looks for the first characters
+                return s.rfind("--", 0) == 0 && s != "--validate";
+            });
+        if (invalid_it != args.end()) {
+            throw RuntimeError("Unknown option '" + *invalid_it +
+                               "'. Did you mean '--validate'?");
+        }
+    }
+
+    // --validate should be the last argument (remove it from args)
+    else {
+        if (it != args.end() - 1) {
+            throw RuntimeError("'--validate' should be the last argument.");
+        }
+        args.pop_back();
+    }
+    return validate;
+}
+
+RegisterAddress Caller::getRegisterAddress(const std::string &saddr) const {
+    if (is_hex_or_dec_uint(saddr)) {
+        return parseRegisterAddress(saddr);
+    }
+    return det->getRegisterAddress(saddr);
+}
+
+BitAddress Caller::getBitAddress() const {
+    int args_size = args.size();
+
+    // address and bit position
+    if (args_size == 2) {
+        return parseBitAddress(args[0], args[1]);
+    }
+
+    // bit name
+    if (args_size == 1) {
+        return det->getBitAddress(args[0]);
+    }
+    throw RuntimeError("Invalid number of parameters for bit address.");
+}
+
 } // namespace sls

slsDetectorSoftware/src/CmdApp.cpp

@@ -83,7 +83,7 @@ int main(int argc, char *argv[]) {
     try {
         if (action == -1) {
             action = inferAction.infer(parser);
-            std::string const actionString =
+            std::string actionString =
                 (action == slsDetectorDefs::GET_ACTION) ? "GET" : "PUT";
             std::cout << "inferred action: " << actionString << std::endl;
         }

slsDetectorSoftware/src/CtbConfig.cpp

@@ -28,214 +28,298 @@ CtbConfig::CtbConfig() {
     for (size_t i = 0; i != num_slowADCs; ++i) {
         setSlowADCName(i, "SLOWADC" + ToString(i));
     }
-}
-
-void CtbConfig::check_dac_index(size_t i) const {
-    if (i >= num_dacs) {
-        std::ostringstream oss;
-        oss << "Invalid DAC index. Options: 0 - " << num_dacs;
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::check_adc_index(size_t i) const {
-    if (i >= num_adcs) {
-        std::ostringstream oss;
-        oss << "Invalid ADC index. Options: 0 - " << num_adcs;
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::check_signal_index(size_t i) const {
-    if (i >= num_signals) {
-        std::ostringstream oss;
-        oss << "Invalid Signal index. Options: 0 - " << num_signals;
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::check_power_index(size_t i) const {
-    if (i >= num_powers) {
-        std::ostringstream oss;
-        oss << "Invalid Power index. Options: 0 - " << num_powers
-            << " or V_POWER_A - V_POWER_IO";
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::check_slow_adc_index(size_t i) const {
-    if (i >= num_slowADCs) {
-        std::ostringstream oss;
-        oss << "Invalid Slow ADC index. Options: 0 - " << num_slowADCs
-            << " or SLOW_ADC0 - SLOW_ADC7";
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::check_size(const std::string &name) const {
-
-    if (name.empty())
-        throw RuntimeError("Name needs to be at least one character");
-
-    // name_length -1 to account for \0 termination
-    if (!(name.size() < (name_length - 1))) {
-        std::ostringstream oss;
-        oss << "Length of name needs to be less than " << name_length - 1
-            << " chars";
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::setDacName(size_t index, const std::string &name) {
-    check_dac_index(index);
-    check_size(name);
-    char *dst = &dacnames[index * name_length];
-    memset(dst, '\0', name_length);
-    memcpy(dst, &name[0], name.size());
-}
-
-void CtbConfig::setDacNames(const std::vector<std::string> &names) {
-    if (names.size() != num_dacs) {
-        throw RuntimeError("Dac names need to be of size " +
-                           std::to_string(num_dacs));
-    }
-    for (size_t i = 0; i != num_dacs; ++i) {
-        setDacName(i, names[i]);
-    }
-}
-
-std::string CtbConfig::getDacName(size_t index) const {
-    check_dac_index(index);
-    return dacnames + index * name_length;
-}
-
-std::vector<std::string> CtbConfig::getDacNames() const {
-    std::vector<std::string> names;
-    for (size_t i = 0; i != num_dacs; ++i)
-        names.push_back(getDacName(i));
-    return names;
-}
-
-void CtbConfig::setAdcName(size_t index, const std::string &name) {
-    check_adc_index(index);
-    check_size(name);
-    char *dst = &adcnames[index * name_length];
-    memset(dst, '\0', name_length);
-    memcpy(dst, &name[0], name.size());
-}
-
-void CtbConfig::setAdcNames(const std::vector<std::string> &names) {
-    if (names.size() != num_adcs) {
-        throw RuntimeError("Adc names need to be of size " +
-                           std::to_string(num_adcs));
-    }
-    for (size_t i = 0; i != num_adcs; ++i) {
-        setAdcName(i, names[i]);
-    }
-}
-
-std::string CtbConfig::getAdcName(size_t index) const {
-    check_adc_index(index);
-    return adcnames + index * name_length;
-}
-
-std::vector<std::string> CtbConfig::getAdcNames() const {
-    std::vector<std::string> names;
-    for (size_t i = 0; i != num_adcs; ++i)
-        names.push_back(getAdcName(i));
-    return names;
-}
-
-void CtbConfig::setSignalName(size_t index, const std::string &name) {
-    check_signal_index(index);
-    check_size(name);
-    char *dst = &signalnames[index * name_length];
-    memset(dst, '\0', name_length);
-    memcpy(dst, &name[0], name.size());
-}
-
-void CtbConfig::setSignalNames(const std::vector<std::string> &names) {
-    if (names.size() != num_signals) {
-        throw RuntimeError("Signal names need to be of size " +
-                           std::to_string(num_signals));
-    }
-    for (size_t i = 0; i != num_signals; ++i) {
-        setSignalName(i, names[i]);
-    }
-}
-
-std::string CtbConfig::getSignalName(size_t index) const {
-    check_signal_index(index);
-    return signalnames + index * name_length;
-}
-
-std::vector<std::string> CtbConfig::getSignalNames() const {
-    std::vector<std::string> names;
-    for (size_t i = 0; i != num_signals; ++i)
-        names.push_back(getSignalName(i));
-    return names;
-}
-
-void CtbConfig::setPowerName(size_t index, const std::string &name) {
-    check_power_index(index);
-    check_size(name);
-    char *dst = &powernames[index * name_length];
-    memset(dst, '\0', name_length);
-    memcpy(dst, &name[0], name.size());
-}
-
-void CtbConfig::setPowerNames(const std::vector<std::string> &names) {
-    if (names.size() != num_powers) {
-        throw RuntimeError("Power names need to be of size " +
-                           std::to_string(num_powers));
-    }
-    for (size_t i = 0; i != num_powers; ++i) {
-        setPowerName(i, names[i]);
-    }
-}
-
-std::string CtbConfig::getPowerName(size_t index) const {
-    check_power_index(index);
-    return powernames + index * name_length;
-}
-
-std::vector<std::string> CtbConfig::getPowerNames() const {
-    std::vector<std::string> names;
-    for (size_t i = 0; i != num_powers; ++i)
-        names.push_back(getPowerName(i));
-    return names;
-}
-
-void CtbConfig::setSlowADCName(size_t index, const std::string &name) {
-    check_slow_adc_index(index);
-    check_size(name);
-    char *dst = &slowADCnames[index * name_length];
-    memset(dst, '\0', name_length);
-    memcpy(dst, &name[0], name.size());
-}
-
-void CtbConfig::setSlowADCNames(const std::vector<std::string> &names) {
-    if (names.size() != num_slowADCs) {
-        throw RuntimeError("Slow ADC names need to be of size " +
-                           std::to_string(num_slowADCs));
-    }
-    for (size_t i = 0; i != num_slowADCs; ++i) {
-        setSlowADCName(i, names[i]);
-    }
-}
-
-std::string CtbConfig::getSlowADCName(size_t index) const {
-    check_slow_adc_index(index);
-    return slowADCnames + index * name_length;
-}
-
-std::vector<std::string> CtbConfig::getSlowADCNames() const {
-    std::vector<std::string> names;
-    for (size_t i = 0; i != num_slowADCs; ++i)
-        names.push_back(getSlowADCName(i));
-    return names;
+    registers.clear();
+    bits.clear();
 }
 
 const char *CtbConfig::shm_tag() { return shm_tag_; }
 
+void CtbConfig::check_index(size_t index, size_t max, const std::string &name,
+                            const std::string &suffix) const {
+    if (index >= max) {
+        std::ostringstream oss;
+        oss << "Invalid " << name << " index. Options: 0 - " << max;
+        if (!suffix.empty()) {
+            oss << " " << suffix;
+        }
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::set_name(const std::string &name, char dst[][name_length],
+                         size_t index) {
+    if (name.empty())
+        throw RuntimeError("Name needs to be at least one character");
+
+    strcpy_checked<name_length>(dst[index], name);
+}
+
+void CtbConfig::setNames(const std::vector<std::string> &names,
+                         size_t expected_size,
+                         void (CtbConfig::*setNameFunc)(size_t,
+                                                        const std::string &)) {
+    if (names.size() != expected_size) {
+        throw RuntimeError("Name list need to be of size " +
+                           std::to_string(expected_size));
+    }
+    for (size_t i = 0; i != expected_size; ++i) {
+        (this->*setNameFunc)(i, names[i]);
+    }
+}
+
+std::vector<std::string>
+CtbConfig::getNames(size_t expected_size,
+                    std::string (CtbConfig::*getNameFunc)(size_t) const) const {
+    std::vector<std::string> result;
+    result.reserve(expected_size);
+    for (size_t i = 0; i != expected_size; ++i) {
+        result.push_back((this->*getNameFunc)(i));
+    }
+    return result;
+}
+
+void CtbConfig::setDacName(size_t index, const std::string &name) {
+    check_index(index, num_dacs, "DAC");
+    set_name(name, dacnames, index);
+}
+
+void CtbConfig::setDacNames(const std::vector<std::string> &names) {
+    setNames(names, num_dacs, &CtbConfig::setDacName);
+}
+
+std::string CtbConfig::getDacName(size_t index) const {
+    check_index(index, num_dacs, "DAC");
+    return dacnames[index];
+}
+
+std::vector<std::string> CtbConfig::getDacNames() const {
+    return getNames(num_dacs, &CtbConfig::getDacName);
+}
+
+void CtbConfig::setAdcName(size_t index, const std::string &name) {
+    check_index(index, num_adcs, "ADC");
+    set_name(name, adcnames, index);
+}
+
+void CtbConfig::setAdcNames(const std::vector<std::string> &names) {
+    setNames(names, num_adcs, &CtbConfig::setAdcName);
+}
+
+std::string CtbConfig::getAdcName(size_t index) const {
+    check_index(index, num_adcs, "ADC");
+    return adcnames[index];
+}
+
+std::vector<std::string> CtbConfig::getAdcNames() const {
+    return getNames(num_adcs, &CtbConfig::getAdcName);
+}
+
+void CtbConfig::setSignalName(size_t index, const std::string &name) {
+    check_index(index, num_signals, "Signal");
+    set_name(name, signalnames, index);
+}
+
+void CtbConfig::setSignalNames(const std::vector<std::string> &names) {
+    setNames(names, num_signals, &CtbConfig::setSignalName);
+}
+
+std::string CtbConfig::getSignalName(size_t index) const {
+    check_index(index, num_signals, "Signal");
+    return signalnames[index];
+}
+
+std::vector<std::string> CtbConfig::getSignalNames() const {
+    return getNames(num_signals, &CtbConfig::getSignalName);
+}
+
+void CtbConfig::setPowerName(size_t index, const std::string &name) {
+    check_index(index, num_powers, "Power");
+    set_name(name, powernames, index);
+}
+
+void CtbConfig::setPowerNames(const std::vector<std::string> &names) {
+    setNames(names, num_powers, &CtbConfig::setPowerName);
+}
+
+std::string CtbConfig::getPowerName(size_t index) const {
+    check_index(index, num_powers, "Power");
+    return powernames[index];
+}
+
+std::vector<std::string> CtbConfig::getPowerNames() const {
+    return getNames(num_powers, &CtbConfig::getPowerName);
+}
+
+void CtbConfig::setSlowADCName(size_t index, const std::string &name) {
+    check_index(index, num_slowADCs, "Slow ADC", "or SLOW_ADC0 - SLOW_ADC7");
+    set_name(name, slowADCnames, index);
+}
+
+void CtbConfig::setSlowADCNames(const std::vector<std::string> &names) {
+    setNames(names, num_slowADCs, &CtbConfig::setSlowADCName);
+}
+
+std::string CtbConfig::getSlowADCName(size_t index) const {
+    check_index(index, num_slowADCs, "Slow ADC", "or SLOW_ADC0 - SLOW_ADC7");
+    return slowADCnames[index];
+}
+
+std::vector<std::string> CtbConfig::getSlowADCNames() const {
+    return getNames(num_slowADCs, &CtbConfig::getSlowADCName);
+}
+
+int CtbConfig::getRegisterNamesCount() const { return registers.size(); }
+
+bool CtbConfig::hasRegisterName(const std::string &name) const {
+    auto fixed_name = FixedString<name_length>(name);
+    return registers.containsKey(fixed_name);
+}
+
+bool CtbConfig::hasRegisterAddress(RegisterAddress addr) const {
+    return registers.hasValue(addr);
+}
+
+void CtbConfig::clearRegisterNames() { registers.clear(); }
+
+void CtbConfig::setRegisterName(const std::string &name, RegisterAddress addr) {
+    try {
+        auto fixed_name = FixedString<name_length>(name);
+        registers.addKeyOrSetValue(fixed_name, addr);
+    } catch (const std::runtime_error &e) {
+        std::ostringstream oss;
+        oss << e.what();
+        if (strstr(e.what(), "Maximum capacity reached")) {
+            oss << ". Clear shared memory and try again.";
+        }
+        throw RuntimeError("Could not set register name '" + name +
+                           "': " + oss.str());
+    }
+}
+
+RegisterAddress CtbConfig::getRegisterAddress(const std::string &name) const {
+    try {
+        auto fixed_name = FixedString<name_length>(name);
+        return registers.getValue(fixed_name);
+    } catch (const std::runtime_error &e) {
+        throw RuntimeError("Could not get register address for name '" + name +
+                           "': " + std::string(e.what()));
+    }
+}
+
+std::string CtbConfig::getRegisterName(RegisterAddress addr) const {
+    try {
+        return registers.getKey(addr).str();
+    } catch (const std::runtime_error &e) {
+        throw RuntimeError("Could not get register name for address '" +
+                           addr.str() + "': " + std::string(e.what()));
+    }
+}
+
+void CtbConfig::setRegisterNames(
+    const std::map<std::string, RegisterAddress> &list) {
+    try {
+        std::map<FixedString<name_length>, RegisterAddress> fixed_list;
+        for (const auto &[name, value] : list) {
+            auto fixed_name = FixedString<name_length>(name);
+            fixed_list[fixed_name] = value;
+        }
+        registers.setMap(fixed_list);
+    } catch (const std::runtime_error &e) {
+        throw RuntimeError("Could not set register names: " +
+                           std::string(e.what()));
+    }
+}
+
+std::map<std::string, RegisterAddress> CtbConfig::getRegisterNames() const {
+    auto fixed_result = registers.getMap();
+    std::map<std::string, RegisterAddress> result;
+    for (const auto &[fixed_name, value] : fixed_result) {
+        result[fixed_name.str()] = value;
+    }
+    return result;
+}
+
+int CtbConfig::getBitNamesCount() const { return bits.size(); }
+
+bool CtbConfig::hasBitName(const std::string &name) const {
+    auto fixed_name = FixedString<name_length>(name);
+    return bits.containsKey(fixed_name);
+}
+
+bool CtbConfig::hasBitAddress(BitAddress addr) const {
+    return bits.hasValue(addr);
+}
+
+void CtbConfig::clearBitNames() { bits.clear(); }
+
+void CtbConfig::setBitName(const std::string &name, BitAddress addr) {
+    try {
+        auto fixed_name = FixedString<name_length>(name);
+        bits.addKeyOrSetValue(fixed_name, addr);
+    } catch (const std::runtime_error &e) {
+        std::ostringstream oss;
+        oss << e.what();
+        if (strstr(e.what(), "Maximum capacity reached")) {
+            oss << ". Clear shared memory and try again.";
+        }
+        throw RuntimeError("Could not set bit name '" + name +
+                           "': " + oss.str());
+    }
+}
+
+BitAddress CtbConfig::getBitAddress(const std::string &name) const {
+    try {
+        auto fixed_name = FixedString<name_length>(name);
+        return bits.getValue(fixed_name);
+    } catch (const std::runtime_error &e) {
+        throw RuntimeError("Could not get bit address for name '" + name +
+                           "': " + std::string(e.what()));
+    }
+}
+
+std::string CtbConfig::toRegisterNameBitString(BitAddress addr) const {
+    std::ostringstream oss;
+    if (registers.hasValue(addr.address())) {
+        oss << "[" << registers.getKey(addr.address()).str() << ", "
+            << std::to_string(addr.bitPosition()) << "]";
+    } else {
+        oss << addr.str();
+    }
+    return oss.str();
+}
+
+std::string CtbConfig::getBitName(BitAddress addr) const {
+    try {
+        return bits.getKey(addr).str();
+    } catch (const std::runtime_error &e) {
+        std::ostringstream oss;
+        oss << "Could not get bit name for bit address ";
+        oss << "'" << toRegisterNameBitString(addr) << "'";
+        oss << ":" << e.what();
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::setBitNames(const std::map<std::string, BitAddress> &list) {
+    try {
+        std::map<FixedString<name_length>, BitAddress> fixed_list;
+        for (const auto &[name, value] : list) {
+            auto fixed_name = FixedString<name_length>(name);
+            fixed_list[fixed_name] = value;
+        }
+        bits.setMap(fixed_list);
+    } catch (const std::runtime_error &e) {
+        throw RuntimeError("Could not set bit names: " + std::string(e.what()));
+    }
+}
+
+std::map<std::string, BitAddress> CtbConfig::getBitNames() const {
+    auto fixed_result = bits.getMap();
+    std::map<std::string, BitAddress> result;
+    for (const auto &[fixed_name, value] : fixed_result) {
+        result[fixed_name.str()] = value;
+    }
+    return result;
+}
+
 } // namespace sls

slsDetectorSoftware/src/CtbConfig.h

@@ -1,44 +1,57 @@
 #pragma once
-#include <string>
-#include <vector>
-namespace sls {
 
-#define CTB_SHMAPIVERSION 0x250820
-#define CTB_SHMVERSION    0x250820
+#include "MapOnStack.h"
+#include "sls/bit_utils.h"
+#include "sls/sls_detector_defs.h"
+#include "sls/string_utils.h"
+
+#include <vector>
+
+namespace sls {
 
 class CtbConfig {
   public:
     /** fixed pattern */
-    int shmversion{CTB_SHMVERSION};
+    static constexpr int SHM_VERSION = 0x251215;
+    int shmversion{SHM_VERSION};
     bool isValid{true}; // false if freed to block access from python or c++ api
                         /** end of fixed pattern */
+
   private:
-    static constexpr size_t name_length = 20;
+    static constexpr const char *shm_tag_ = "ctbdacs";
+    static constexpr size_t name_length = 32;
+
     static constexpr size_t num_dacs = 18;
     static constexpr size_t num_adcs = 32;
     static constexpr size_t num_signals = 64;
     static constexpr size_t num_powers = 5;
     static constexpr size_t num_slowADCs = 8;
-    static constexpr const char *shm_tag_ = "ctbdacs";
-    char dacnames[name_length * num_dacs]{};
-    char adcnames[name_length * num_adcs]{};
-    char signalnames[name_length * num_signals]{};
-    char powernames[name_length * num_powers]{};
-    char slowADCnames[name_length * num_slowADCs]{};
+    char dacnames[num_dacs][name_length]{};
+    char adcnames[num_adcs][name_length]{};
+    char signalnames[num_signals][name_length]{};
+    char powernames[num_powers][name_length]{};
+    char slowADCnames[num_slowADCs][name_length]{};
 
-    void check_dac_index(size_t i) const;
-    void check_adc_index(size_t i) const;
-    void check_signal_index(size_t i) const;
-    void check_power_index(size_t i) const;
-    void check_slow_adc_index(size_t i) const;
-    void check_size(const std::string &name) const;
+    void check_index(size_t index, size_t max, const std::string &name,
+                     const std::string &suffix = "") const;
+    void set_name(const std::string &name, char dst[][name_length],
+                  size_t index);
+
+    void setNames(const std::vector<std::string> &names, size_t expected_size,
+                  void (CtbConfig::*setNameFunc)(size_t, const std::string &));
+    std::vector<std::string>
+    getNames(size_t expected_size,
+             std::string (CtbConfig::*getNameFunc)(size_t) const) const;
+
+    static constexpr size_t Max_Named_Regs = 1024;
+    static constexpr size_t Max_Named_Bits = 32 * 1024;
+    MapOnStack<FixedString<name_length>, RegisterAddress, Max_Named_Regs, true>
+        registers;
+    MapOnStack<FixedString<name_length>, BitAddress, Max_Named_Bits, true> bits;
 
   public:
     CtbConfig();
-    CtbConfig(const CtbConfig &) = default;
-    CtbConfig(CtbConfig &&) = default;
-    CtbConfig &operator=(const CtbConfig &) = default;
-    ~CtbConfig() = default;
+    static const char *shm_tag();
 
     void setDacNames(const std::vector<std::string> &names);
     void setDacName(size_t index, const std::string &name);
@@ -64,7 +77,27 @@ class CtbConfig {
     void setSlowADCName(size_t index, const std::string &name);
     std::string getSlowADCName(size_t index) const;
     std::vector<std::string> getSlowADCNames() const;
-    static const char *shm_tag();
+
+    int getRegisterNamesCount() const;
+    bool hasRegisterName(const std::string &name) const;
+    bool hasRegisterAddress(RegisterAddress addr) const;
+    void clearRegisterNames();
+    void setRegisterName(const std::string &name, RegisterAddress addr);
+    RegisterAddress getRegisterAddress(const std::string &name) const;
+    std::string getRegisterName(RegisterAddress addr) const;
+    void setRegisterNames(const std::map<std::string, RegisterAddress> &list);
+    std::map<std::string, RegisterAddress> getRegisterNames() const;
+
+    int getBitNamesCount() const;
+    void clearBitNames();
+    bool hasBitName(const std::string &name) const;
+    bool hasBitAddress(BitAddress addr) const;
+    std::string toRegisterNameBitString(BitAddress addr) const;
+    void setBitName(const std::string &name, BitAddress addr);
+    BitAddress getBitAddress(const std::string &name) const;
+    std::string getBitName(BitAddress addr) const;
+    void setBitNames(const std::map<std::string, BitAddress> &list);
+    std::map<std::string, BitAddress> getBitNames() const;
 };
 
 } // namespace sls

slsDetectorSoftware/src/Detector.cpp

@@ -128,7 +128,7 @@ Detector &Detector::operator=(Detector &&other) noexcept = default;
 // Configuration
 
 void Detector::loadConfig(const std::string &fname) {
-    const int shm_id = getShmId();
+    int shm_id = getShmId();
     freeSharedMemory(shm_id);
     pimpl = make_unique<DetectorImpl>(shm_id);
     LOG(logINFO) << "Loading configuration file: " << fname;
@@ -205,7 +205,7 @@ int Detector::getShmId() const { return pimpl->getDetectorIndex(); }
 std::string Detector::getPackageVersion() const { return SLS_DET_VERSION; }
 
 std::string Detector::getClientVersion() const {
-    const Version v(APILIB);
+    Version v(APILIB);
     return v.concise();
 }
 
@@ -266,7 +266,7 @@ defs::xy Detector::getPortPerModuleGeometry() const {
 
 Result<defs::xy> Detector::getPortSize(Positions pos) const {
     Result<defs::xy> res = pimpl->Parallel(&Module::getNumberOfChannels, pos);
-    const defs::xy portGeometry = getPortPerModuleGeometry();
+    defs::xy portGeometry = getPortPerModuleGeometry();
     if ((portGeometry.x != 1 && portGeometry.x != 2) ||
         (portGeometry.y != 1 && portGeometry.y != 2)) {
         throw RuntimeError(
@@ -346,9 +346,9 @@ Detector::getAllThresholdEnergy(Positions pos) const {
 void Detector::setThresholdEnergy(int threshold_ev,
                                   defs::detectorSettings settings,
                                   bool trimbits, Positions pos) {
-    const defs::detectorType type = getDetectorType().squash();
+    defs::detectorType type = getDetectorType().squash();
     if (type == defs::MYTHEN3) {
-        const std::array<int, 3> energy = {threshold_ev, threshold_ev, threshold_ev};
+        std::array<int, 3> energy = {threshold_ev, threshold_ev, threshold_ev};
         setThresholdEnergy(energy, settings, trimbits, pos);
         return;
     }
@@ -753,6 +753,7 @@ void Detector::setImageTestMode(int value, Positions pos) {
 }
 
 std::vector<defs::dacIndex> Detector::getTemperatureList() const {
+    std::vector<defs::dacIndex> retval;
     switch (getDetectorType().squash()) {
     case defs::CHIPTESTBOARD:
         return std::vector<defs::dacIndex>{defs::SLOW_ADC_TEMP};
@@ -1095,9 +1096,9 @@ void Detector::setNumberofUDPInterfaces_(int n, Positions pos) {
     if (!size()) {
         throw RuntimeError("No modules added.");
     }
-    const bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
-    const uint16_t clientStartingPort = getClientZmqPort({0}).squash(0);
-    const bool useReceiver = getUseReceiverFlag().squash(false);
+    bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
+    uint16_t clientStartingPort = getClientZmqPort({0}).squash(0);
+    bool useReceiver = getUseReceiverFlag().squash(false);
     bool previouslyReceiverStreaming = false;
     uint16_t rxStartingPort = 0;
     if (useReceiver) {
@@ -1563,7 +1564,7 @@ Result<uint16_t> Detector::getRxZmqPort(Positions pos) const {
 }
 
 void Detector::setRxZmqPort(uint16_t port, int module_id) {
-    const bool previouslyReceiverStreaming =
+    bool previouslyReceiverStreaming =
         getRxZmqDataStream(std::vector<int>{module_id}).squash(false);
     if (module_id == -1) {
         std::vector<uint16_t> port_list = getValidPortNumbers(port);
@@ -1586,7 +1587,7 @@ Result<uint16_t> Detector::getClientZmqPort(Positions pos) const {
 }
 
 void Detector::setClientZmqPort(uint16_t port, int module_id) {
-    const bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
+    bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
     if (module_id == -1) {
         std::vector<uint16_t> port_list = getValidPortNumbers(port);
         for (int idet = 0; idet < size(); ++idet) {
@@ -1608,7 +1609,7 @@ Result<IpAddr> Detector::getClientZmqIp(Positions pos) const {
 }
 
 void Detector::setClientZmqIp(const IpAddr ip, Positions pos) {
-    const bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
+    bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
     pimpl->Parallel(&Module::setClientStreamingIP, pos, ip);
     if (previouslyClientStreaming) {
         pimpl->setDataStreamingToClient(false);
@@ -1627,7 +1628,7 @@ Result<int> Detector::getRxZmqHwm(Positions pos) const {
 }
 
 void Detector::setRxZmqHwm(const int limit) {
-    const bool previouslyReceiverStreaming = getRxZmqDataStream().squash(false);
+    bool previouslyReceiverStreaming = getRxZmqDataStream().squash(false);
     pimpl->Parallel(&Module::setReceiverStreamingHwm, {}, limit);
     if (previouslyReceiverStreaming) {
         setRxZmqDataStream(false, {});
@@ -1993,15 +1994,15 @@ Result<defs::streamingInterface> Detector::getVetoStream(Positions pos) const {
 void Detector::setVetoStream(defs::streamingInterface interface,
                              Positions pos) {
     // 3gbe
-    const bool LOW_LATENCY_LINK =
+    bool LOW_LATENCY_LINK =
         ((interface & defs::streamingInterface::LOW_LATENCY_LINK) ==
          defs::streamingInterface::LOW_LATENCY_LINK);
     pimpl->Parallel(&Module::setVetoStream, pos, LOW_LATENCY_LINK);
 
     // 10gbe (debugging interface) opens 2nd udp interface in receiver
-    const int old_numinterfaces = getNumberofUDPInterfaces(pos).tsquash(
+    int old_numinterfaces = getNumberofUDPInterfaces(pos).tsquash(
         "retrieved inconsistent number of udp interfaces");
-    const int numinterfaces =
+    int numinterfaces =
         (((interface & defs::streamingInterface::ETHERNET_10GB) ==
           defs::streamingInterface::ETHERNET_10GB)
              ? 2
@@ -2376,26 +2377,21 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
 }
 
 void Detector::setDacNames(const std::vector<std::string> names) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named dacs only for CTB");
     pimpl->setCtbDacNames(names);
 }
 
 std::vector<std::string> Detector::getDacNames() const {
-    std::vector<std::string> names;
-    auto type = getDetectorType().squash();
-    if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD)
+    if (pimpl->isChipTestBoard())
         return pimpl->getCtbDacNames();
 
+    std::vector<std::string> names;
     for (const auto &index : getDacList())
         names.push_back(ToString(index));
     return names;
 }
 
 defs::dacIndex Detector::getDacIndex(const std::string &name) const {
-    auto type = getDetectorType().squash();
-    if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD) {
+    if (pimpl->isChipTestBoard()) {
         auto names = getDacNames();
         auto it = std::find(names.begin(), names.end(), name);
         if (it == names.end())
@@ -2406,37 +2402,24 @@ defs::dacIndex Detector::getDacIndex(const std::string &name) const {
 }
 
 void Detector::setDacName(const defs::dacIndex i, const std::string &name) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named dacs only for CTB");
     pimpl->setCtbDacName(i, name);
 }
 
 std::string Detector::getDacName(const defs::dacIndex i) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype == defs::CHIPTESTBOARD || dettype == defs::XILINX_CHIPTESTBOARD)
+    if (pimpl->isChipTestBoard())
         return pimpl->getCtbDacName(i);
     return ToString(i);
 }
 
 void Detector::setAdcNames(const std::vector<std::string> names) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named adcs only for CTB");
     pimpl->setCtbAdcNames(names);
 }
 
 std::vector<std::string> Detector::getAdcNames() const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named adcs only for CTB");
     return pimpl->getCtbAdcNames();
 }
 
 int Detector::getAdcIndex(const std::string &name) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named adcs only for CTB");
     auto names = getAdcNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2445,37 +2428,22 @@ int Detector::getAdcIndex(const std::string &name) const {
 }
 
 void Detector::setAdcName(const int index, const std::string &name) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named adcs only for CTB");
     pimpl->setCtbAdcName(index, name);
 }
 
 std::string Detector::getAdcName(const int i) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named adcs only for CTB");
     return pimpl->getCtbAdcName(i);
 }
 
 void Detector::setSignalNames(const std::vector<std::string> names) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named signals only for CTB");
     pimpl->setCtbSignalNames(names);
 }
 
 std::vector<std::string> Detector::getSignalNames() const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named signals only for CTB");
     return pimpl->getCtbSignalNames();
 }
 
 int Detector::getSignalIndex(const std::string &name) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named signals only for CTB");
     auto names = getSignalNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2484,38 +2452,22 @@ int Detector::getSignalIndex(const std::string &name) const {
 }
 
 void Detector::setSignalName(const int index, const std::string &name) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named signals only for CTB");
     pimpl->setCtbSignalName(index, name);
 }
 
 std::string Detector::getSignalName(const int i) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named signals only for CTB");
     return pimpl->getCtbSignalName(i);
 }
 
 void Detector::setPowerNames(const std::vector<std::string> names) {
-    auto dettype = getDetectorType().squash();
-    if (getDetectorType().squash() != defs::CHIPTESTBOARD &&
-        dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named powers only for CTB");
     pimpl->setCtbPowerNames(names);
 }
 
 std::vector<std::string> Detector::getPowerNames() const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named powers only for CTB");
     return pimpl->getCtbPowerNames();
 }
 
 defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named powers only for CTB");
     auto names = getPowerNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2525,37 +2477,22 @@ defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
 
 void Detector::setPowerName(const defs::dacIndex index,
                             const std::string &name) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named powers only for CTB");
     pimpl->setCtbPowerName(index, name);
 }
 
 std::string Detector::getPowerName(const defs::dacIndex i) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named powers only for CTB");
     return pimpl->getCtbPowerName(i);
 }
 
 void Detector::setSlowADCNames(const std::vector<std::string> names) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named SlowADCs only for CTB");
     pimpl->setCtbSlowADCNames(names);
 }
 
 std::vector<std::string> Detector::getSlowADCNames() const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named SlowADCs only for CTB");
     return pimpl->getCtbSlowADCNames();
 }
 
 defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named SlowADCs only for CTB");
     auto names = getSlowADCNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2565,19 +2502,89 @@ defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
 
 void Detector::setSlowADCName(const defs::dacIndex index,
                               const std::string &name) {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named SlowADCs only for CTB");
     pimpl->setCtbSlowADCName(index, name);
 }
 
 std::string Detector::getSlowADCName(const defs::dacIndex i) const {
-    auto dettype = getDetectorType().squash();
-    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
-        throw RuntimeError("Named SlowADCs only for CTB");
     return pimpl->getCtbSlowADCName(i);
 }
 
+int Detector::getRegisterDefinitionsCount() const {
+    return pimpl->getRegisterDefinitionsCount();
+}
+
+void Detector::setRegisterDefinition(const std::string &name,
+                                     RegisterAddress addr) {
+    pimpl->setRegisterDefinition(name, addr);
+}
+
+bool Detector::hasRegisterDefinition(const std::string &name) const {
+    return pimpl->hasRegisterDefinition(name);
+}
+
+bool Detector::hasRegisterDefinition(RegisterAddress addr) const {
+    return pimpl->hasRegisterDefinition(addr);
+}
+
+RegisterAddress Detector::getRegisterAddress(const std::string &name) const {
+    return pimpl->getRegisterAddress(name);
+}
+
+std::string Detector::getRegisterName(RegisterAddress addr) const {
+    return pimpl->getRegisterName(addr);
+}
+
+void Detector::clearRegisterDefinitions() { pimpl->clearRegisterDefinitions(); }
+
+void Detector::setRegisterDefinitions(
+    const std::map<std::string, RegisterAddress> &list) {
+    pimpl->setRegisterDefinitions(list);
+}
+
+std::map<std::string, RegisterAddress>
+Detector::getRegisterDefinitions() const {
+    return pimpl->getRegisterDefinitions();
+}
+
+int Detector::getBitDefinitionsCount() const {
+    return pimpl->getBitDefinitionsCount();
+}
+
+void Detector::setBitDefinition(const std::string &name, BitAddress addr) {
+    pimpl->setBitDefinition(name, addr);
+}
+
+bool Detector::hasBitDefinition(const std::string &name) const {
+    return pimpl->hasBitDefinition(name);
+}
+
+bool Detector::hasBitDefinition(BitAddress addr) const {
+    return pimpl->hasBitDefinition(addr);
+}
+
+std::string Detector::toRegisterNameBitString(BitAddress addr) const {
+    return pimpl->toRegisterNameBitString(addr);
+}
+
+BitAddress Detector::getBitAddress(const std::string &name) const {
+    return pimpl->getBitAddress(name);
+}
+
+std::string Detector::getBitName(BitAddress addr) const {
+    return pimpl->getBitName(addr);
+}
+
+void Detector::clearBitDefinitions() { pimpl->clearBitDefinitions(); }
+
+void Detector::setBitDefinitions(
+    const std::map<std::string, BitAddress> &list) {
+    pimpl->setBitDefinitions(list);
+}
+
+std::map<std::string, BitAddress> Detector::getBitDefinitions() const {
+    return pimpl->getBitDefinitions();
+}
+
 // Xilinx Ctb Specific
 
 void Detector::configureTransceiver(Positions pos) {
@@ -2729,7 +2736,7 @@ void Detector::programFPGA(const std::string &fname,
                            const bool forceDeleteNormalFile, Positions pos) {
     LOG(logINFO) << "Updating Firmware...";
     LOG(logINFO) << "Hardware Version: " << getHardwareVersion();
-    const std::vector<char> buffer = pimpl->readProgrammingFile(fname);
+    std::vector<char> buffer = pimpl->readProgrammingFile(fname);
     pimpl->Parallel(&Module::programFPGA, pos, buffer, forceDeleteNormalFile);
     rebootController(pos);
 }
@@ -2740,8 +2747,8 @@ void Detector::resetFPGA(Positions pos) {
 
 void Detector::updateDetectorServer(const std::string &fname, Positions pos) {
     LOG(logINFO) << "Updating Detector Server (no tftp)...";
-    const std::vector<char> buffer = readBinaryFile(fname, "Update Detector Server");
-    const std::string filename = getFileNameFromFilePath(fname);
+    std::vector<char> buffer = readBinaryFile(fname, "Update Detector Server");
+    std::string filename = getFileNameFromFilePath(fname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
     if (getDetectorType().squash() != defs::EIGER) {
         rebootController(pos);
@@ -2750,7 +2757,7 @@ void Detector::updateDetectorServer(const std::string &fname, Positions pos) {
 
 void Detector::updateKernel(const std::string &fname, Positions pos) {
     LOG(logINFO) << "Updating Kernel...";
-    const std::vector<char> buffer = readBinaryFile(fname, "Update Kernel");
+    std::vector<char> buffer = readBinaryFile(fname, "Update Kernel");
     pimpl->Parallel(&Module::updateKernel, pos, buffer);
     rebootController(pos);
 }
@@ -2764,8 +2771,8 @@ void Detector::updateFirmwareAndServer(const std::string &sname,
                                        Positions pos) {
     LOG(logINFO) << "Updating Firmware and Detector Server (no tftp)...";
     LOG(logINFO) << "Updating Detector Server (no tftp)...";
-    const std::vector<char> buffer = readBinaryFile(sname, "Update Detector Server");
-    const std::string filename = getFileNameFromFilePath(sname);
+    std::vector<char> buffer = readBinaryFile(sname, "Update Detector Server");
+    std::string filename = getFileNameFromFilePath(sname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
     programFPGA(fname, false, pos);
 }
@@ -2781,26 +2788,78 @@ void Detector::setUpdateMode(const bool updatemode, Positions pos) {
     }
 }
 
+Result<RegisterValue> Detector::readRegister(RegisterAddress addr,
+                                             Positions pos) const {
+    return pimpl->readRegister(addr, pos);
+}
+
+void Detector::writeRegister(RegisterAddress addr, RegisterValue val,
+                             bool validate, Positions pos) {
+    pimpl->writeRegister(addr, val, validate, pos);
+}
+
+void Detector::setBit(BitAddress addr, bool validate, Positions pos) {
+    pimpl->setBit(addr, validate, pos);
+}
+
+void Detector::clearBit(BitAddress addr, bool validate, Positions pos) {
+    pimpl->clearBit(addr, validate, pos);
+}
+
+Result<int> Detector::getBit(BitAddress addr, Positions pos) const {
+    return pimpl->getBit(addr, pos);
+}
+
+Result<RegisterValue> Detector::readRegister(const std::string &reg_name,
+                                             Positions pos) const {
+    return pimpl->readRegister(reg_name, pos);
+}
+
+void Detector::writeRegister(const std::string &reg_name, RegisterValue val,
+                             bool validate, Positions pos) {
+    pimpl->writeRegister(reg_name, val, validate, pos);
+}
+
+void Detector::setBit(const std::string &bit_name, bool validate,
+                      Positions pos) {
+    pimpl->setBit(bit_name, validate, pos);
+}
+
+void Detector::clearBit(const std::string &bit_name, bool validate,
+                        Positions pos) {
+    pimpl->clearBit(bit_name, validate, pos);
+}
+
+Result<int> Detector::getBit(const std::string &bit_name, Positions pos) const {
+    return pimpl->getBit(bit_name, pos);
+}
+
 Result<uint32_t> Detector::readRegister(uint32_t addr, Positions pos) const {
-    return pimpl->Parallel(&Module::readRegister, pos, addr);
+    auto t = pimpl->readRegister(RegisterAddress(addr), pos);
+    Result<uint32_t> res;
+    for (const auto &val : t) {
+        res.push_back(val.value());
+    }
+    return res;
 }
 
 void Detector::writeRegister(uint32_t addr, uint32_t val, bool validate,
                              Positions pos) {
-    pimpl->Parallel(&Module::writeRegister, pos, addr, val, validate);
+    pimpl->writeRegister(RegisterAddress(addr), RegisterValue(val), validate,
+                         pos);
 }
 
 void Detector::setBit(uint32_t addr, int bitnr, bool validate, Positions pos) {
-    pimpl->Parallel(&Module::setBit, pos, addr, bitnr, validate);
+    pimpl->setBit(BitAddress(RegisterAddress(addr), bitnr), validate, pos);
 }
 
 void Detector::clearBit(uint32_t addr, int bitnr, bool validate,
                         Positions pos) {
-    pimpl->Parallel(&Module::clearBit, pos, addr, bitnr, validate);
+    pimpl->clearBit(BitAddress(RegisterAddress(addr), bitnr), validate, pos);
 }
 
-Result<int> Detector::getBit(uint32_t addr, int bitnr, Positions pos) {
-    return pimpl->Parallel(&Module::getBit, pos, addr, bitnr);
+Result<int> Detector::getBit(uint32_t addr, int bitnr, Positions pos) const {
+    return pimpl->getBit(BitAddress(RegisterAddress(addr), bitnr), pos);
 }
 
 void Detector::executeFirmwareTest(Positions pos) {
@@ -2881,7 +2940,7 @@ Result<ns> Detector::getMeasurementTime(Positions pos) const {
 }
 
 std::vector<uint16_t> Detector::getValidPortNumbers(uint16_t start_port) {
-    const int num_sockets_per_detector = getNumberofUDPInterfaces({}).tsquash(
+    int num_sockets_per_detector = getNumberofUDPInterfaces({}).tsquash(
         "Number of UDP Interfaces is not consistent among modules");
 
     validatePortRange(start_port, size() * num_sockets_per_detector);
@@ -2889,7 +2948,7 @@ std::vector<uint16_t> Detector::getValidPortNumbers(uint16_t start_port) {
     std::vector<uint16_t> res;
     res.reserve(size());
     for (int idet = 0; idet < size(); ++idet) {
-        const uint16_t port = start_port + (idet * num_sockets_per_detector);
+        uint16_t port = start_port + (idet * num_sockets_per_detector);
         res.push_back(port);
     }
     return res;

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -80,10 +80,10 @@ void DetectorImpl::initSharedMemory() {
         }
         if (ctb_shm.exists()) {
             ctb_shm.openSharedMemory(true);
-            if (ctb_shm()->shmversion != CTB_SHMVERSION) {
+            if (ctb_shm()->shmversion != CtbConfig::SHM_VERSION) {
                 LOG(logERROR)
                     << "CTB shared memory version mismatch (expected 0x"
-                    << std::hex << CTB_SHMVERSION << " but got 0x"
+                    << std::hex << CtbConfig::SHM_VERSION << " but got 0x"
                     << ctb_shm()->shmversion << std::dec
                     << ". Free Shared memory to continue.";
                 ctb_shm.unmapSharedMemory();
@@ -198,11 +198,11 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
 void DetectorImpl::addModule(const std::string &name) {
     LOG(logINFO) << "Adding module " << name;
     auto host = verifyUniqueDetHost(name);
-    std::string const hostname = host.first;
-    uint16_t const port = host.second;
+    std::string hostname = host.first;
+    uint16_t port = host.second;
 
     // get type by connecting
-    detectorType const type = Module::getTypeFromDetector(hostname, port);
+    detectorType type = Module::getTypeFromDetector(hostname, port);
 
     // gotthard2 cannot have more than 2 modules (50um=1, 25um=2
     if (type == GOTTHARD2 && modules.size() > 2) {
@@ -227,7 +227,7 @@ void DetectorImpl::addModule(const std::string &name) {
     modules[pos]->updateNumberofUDPInterfaces();
 
     // update zmq port in case numudpinterfaces changed
-    int const numInterfaces = modules[pos]->getNumberofUDPInterfacesFromShm();
+    int numInterfaces = modules[pos]->getNumberofUDPInterfacesFromShm();
     modules[pos]->setClientStreamingPort(DEFAULT_ZMQ_CL_PORTNO +
                                          pos * numInterfaces);
 }
@@ -245,7 +245,7 @@ void DetectorImpl::updateDetectorSize() {
     int nModx = 0, nMody = 0;
     // 1d, add modules along x axis
     if (modSize.y == 1) {
-        int const detSizeX = shm()->numberOfChannels.x;
+        int detSizeX = shm()->numberOfChannels.x;
         int maxChanX = modSize.x * size();
         // user given detsizex used only within max value
         if (detSizeX > 1 && detSizeX <= maxChanX) {
@@ -271,7 +271,7 @@ void DetectorImpl::updateDetectorSize() {
     }
     // 2d, add modules along y axis (due to eiger top/bottom)
     else {
-        int const detSizeY = shm()->numberOfChannels.y;
+        int detSizeY = shm()->numberOfChannels.y;
         int maxChanY = modSize.y * size();
         // user given detsizey used only within max value
         if (detSizeY > 1 && detSizeY <= maxChanY) {
@@ -467,7 +467,7 @@ void DetectorImpl::createReceivingDataSockets() {
     if (shm()->detType == GOTTHARD2) {
         numUDPInterfaces = 1;
     }
-    size_t const numSockets = modules.size() * numUDPInterfaces;
+    size_t numSockets = modules.size() * numUDPInterfaces;
 
     for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) {
         uint32_t portnum =
@@ -481,7 +481,7 @@ void DetectorImpl::createReceivingDataSockets() {
                                            .c_str(),
                                        portnum));
             // set high water mark
-            int const hwm = shm()->zmqHwm;
+            int hwm = shm()->zmqHwm;
             if (hwm >= 0) {
                 zmqSocket[iSocket]->SetReceiveHighWaterMark(hwm);
                 // need not reconnect. cannot be connected (detector idle)
@@ -504,7 +504,7 @@ void DetectorImpl::createReceivingDataSockets() {
 
 void DetectorImpl::readFrameFromReceiver() {
 
-    bool const gapPixels = shm()->gapPixels;
+    bool gapPixels = shm()->gapPixels;
     LOG(logDEBUG) << "Gap pixels: " << gapPixels;
     int nX = 0;
     int nY = 0;
@@ -644,10 +644,10 @@ void DetectorImpl::readFrameFromReceiver() {
 
                 // creating multi image
                 {
-                    uint32_t const xoffset = coordX * nPixelsX * bytesPerPixel;
-                    uint32_t const yoffset = coordY * nPixelsY;
+                    uint32_t xoffset = coordX * nPixelsX * bytesPerPixel;
+                    uint32_t yoffset = coordY * nPixelsY;
                     uint32_t singledetrowoffset = nPixelsX * bytesPerPixel;
-                    uint32_t const rowoffset = nX * singledetrowoffset;
+                    uint32_t rowoffset = nX * singledetrowoffset;
                     if (shm()->detType == CHIPTESTBOARD ||
                         shm()->detType == defs::XILINX_CHIPTESTBOARD) {
                         singledetrowoffset = size;
@@ -694,7 +694,7 @@ void DetectorImpl::readFrameFromReceiver() {
             int nDetActualPixelsY = nDetPixelsY;
 
             if (gapPixels) {
-                int const n = insertGapPixels(multiframe.get(), multigappixels,
+                int n = insertGapPixels(multiframe.get(), multigappixels,
                                         quadEnable, dynamicRange,
                                         nDetActualPixelsX, nDetActualPixelsY);
                 callbackImage = multigappixels;
@@ -742,38 +742,38 @@ int DetectorImpl::insertGapPixels(char *image, char *&gpImage, bool quadEnable,
                   << "\n\t quadEnable: " << quadEnable << "\n\t dr: " << dr;
 
     // inter module gap pixels
-    int const modGapPixelsx = 8;
-    int const modGapPixelsy = 36;
+    int modGapPixelsx = 8;
+    int modGapPixelsy = 36;
     // inter chip gap pixels
-    int const chipGapPixelsx = 2;
-    int const chipGapPixelsy = 2;
+    int chipGapPixelsx = 2;
+    int chipGapPixelsy = 2;
     // number of pixels in a chip
-    int const nChipPixelsx = 256;
-    int const nChipPixelsy = 256;
+    int nChipPixelsx = 256;
+    int nChipPixelsy = 256;
     // 1 module
     // number of chips in a module
     int nMod1Chipx = 4;
-    int const nMod1Chipy = 2;
+    int nMod1Chipy = 2;
     if (quadEnable) {
         nMod1Chipx = 2;
     }
     // number of pixels in a module
-    int const nMod1Pixelsx = nChipPixelsx * nMod1Chipx;
-    int const nMod1Pixelsy = nChipPixelsy * nMod1Chipy;
+    int nMod1Pixelsx = nChipPixelsx * nMod1Chipx;
+    int nMod1Pixelsy = nChipPixelsy * nMod1Chipy;
     // number of gap pixels in a module
-    int const nMod1GapPixelsx = (nMod1Chipx - 1) * chipGapPixelsx;
-    int const nMod1GapPixelsy = (nMod1Chipy - 1) * chipGapPixelsy;
+    int nMod1GapPixelsx = (nMod1Chipx - 1) * chipGapPixelsx;
+    int nMod1GapPixelsy = (nMod1Chipy - 1) * chipGapPixelsy;
     // total number of modules
-    int const nModx = nPixelsx / nMod1Pixelsx;
-    int const nMody = nPixelsy / nMod1Pixelsy;
+    int nModx = nPixelsx / nMod1Pixelsx;
+    int nMody = nPixelsy / nMod1Pixelsy;
 
     // check if not full modules
     // (setting gap pixels and then adding half module or disabling quad)
     if (nPixelsy / nMod1Pixelsy == 0) {
         LOG(logERROR) << "Gap pixels can only be enabled with full modules. "
                          "Sending dummy data without gap pixels.\n";
-        double const bytesPerPixel = (double)dr / 8.00;
-        int const imagesize = nPixelsy * nPixelsx * bytesPerPixel;
+        double bytesPerPixel = (double)dr / 8.00;
+        int imagesize = nPixelsy * nPixelsx * bytesPerPixel;
         if (gpImage == nullptr) {
             gpImage = new char[imagesize];
         }
@@ -782,28 +782,28 @@ int DetectorImpl::insertGapPixels(char *image, char *&gpImage, bool quadEnable,
     }
 
     // total number of pixels
-    int const nTotx =
+    int nTotx =
         nPixelsx + (nMod1GapPixelsx * nModx) + (modGapPixelsx * (nModx - 1));
-    int const nToty =
+    int nToty =
         nPixelsy + (nMod1GapPixelsy * nMody) + (modGapPixelsy * (nMody - 1));
     // total number of chips
-    int const nChipx = nPixelsx / nChipPixelsx;
-    int const nChipy = nPixelsy / nChipPixelsy;
+    int nChipx = nPixelsx / nChipPixelsx;
+    int nChipy = nPixelsy / nChipPixelsy;
 
-    double const bytesPerPixel = (double)dr / 8.00;
-    int const imagesize = nTotx * nToty * bytesPerPixel;
+    double bytesPerPixel = (double)dr / 8.00;
+    int imagesize = nTotx * nToty * bytesPerPixel;
 
-    int const nChipBytesx = nChipPixelsx * bytesPerPixel;         // 1 chip bytes in x
-    int const nChipGapBytesx = chipGapPixelsx * bytesPerPixel;    // 2 pixel bytes
-    int const nModGapBytesx = modGapPixelsx * bytesPerPixel;      // 8 pixel bytes
-    int const nChipBytesy = nChipPixelsy * nTotx * bytesPerPixel; // 1 chip bytes in y
-    int const nChipGapBytesy = chipGapPixelsy * nTotx * bytesPerPixel; // 2 lines
-    int const nModGapBytesy = modGapPixelsy * nTotx *
+    int nChipBytesx = nChipPixelsx * bytesPerPixel;         // 1 chip bytes in x
+    int nChipGapBytesx = chipGapPixelsx * bytesPerPixel;    // 2 pixel bytes
+    int nModGapBytesx = modGapPixelsx * bytesPerPixel;      // 8 pixel bytes
+    int nChipBytesy = nChipPixelsy * nTotx * bytesPerPixel; // 1 chip bytes in y
+    int nChipGapBytesy = chipGapPixelsy * nTotx * bytesPerPixel; // 2 lines
+    int nModGapBytesy = modGapPixelsy * nTotx *
                         bytesPerPixel; // 36 lines
                                        // 4 bit mode, its 1 byte (because for 4
                                        // bit mode, we handle 1 byte at a time)
-    int const pixel1 = (int)(ceil(bytesPerPixel));
-    int const row1Bytes = nTotx * bytesPerPixel;
+    int pixel1 = (int)(ceil(bytesPerPixel));
+    int row1Bytes = nTotx * bytesPerPixel;
     int nMod1TotPixelsx = nMod1Pixelsx + nMod1GapPixelsx;
     if (dr == 4) {
         nMod1TotPixelsx /= 2;
@@ -811,7 +811,7 @@ int DetectorImpl::insertGapPixels(char *image, char *&gpImage, bool quadEnable,
     // eiger requires inter chip gap pixels are halved
     // jungfrau/moench prefers same inter chip gap pixels as the boundary pixels
     int divisionValue = 2;
-    slsDetectorDefs::detectorType const detType = shm()->detType;
+    slsDetectorDefs::detectorType detType = shm()->detType;
     if (detType == JUNGFRAU || detType == MOENCH) {
         divisionValue = 1;
     }
@@ -1053,7 +1053,7 @@ int DetectorImpl::getClientStreamingHwm() const {
     for (auto &it : zmqSocket) {
         result.push_back(it->GetReceiveHighWaterMark());
     }
-    int const res = result.tsquash("Inconsistent zmq receive hwm values");
+    int res = result.tsquash("Inconsistent zmq receive hwm values");
     return res;
 }
 
@@ -1110,7 +1110,7 @@ int DetectorImpl::acquire() {
         struct timespec begin, end;
         clock_gettime(CLOCK_REALTIME, &begin);
 
-        bool const receiver = Parallel(&Module::getUseReceiverFlag, {}).squash(false);
+        bool receiver = Parallel(&Module::getUseReceiverFlag, {}).squash(false);
 
         if (dataReady == nullptr) {
             setJoinThreadFlag(false);
@@ -1172,7 +1172,7 @@ int DetectorImpl::acquire() {
 
             // progress
             auto a = Parallel(&Module::getReceiverProgress, {});
-            double const progress = (*std::max_element(a.begin(), a.end()));
+            double progress = (*std::max_element(a.begin(), a.end()));
 
             // callback
             acquisition_finished(progress, static_cast<int>(status),
@@ -1340,7 +1340,7 @@ void DetectorImpl::processData(bool receiver) {
                     }
                 }
                 // get and print progress
-                double const temp =
+                double temp =
                     (double)Parallel(&Module::getReceiverProgress, {0})
                         .squash();
                 if (temp != progress) {
@@ -1365,12 +1365,12 @@ void DetectorImpl::processData(bool receiver) {
 }
 
 bool DetectorImpl::getJoinThreadFlag() const {
-    std::lock_guard<std::mutex> const lock(mp);
+    std::lock_guard<std::mutex> lock(mp);
     return jointhread;
 }
 
 void DetectorImpl::setJoinThreadFlag(bool value) {
-    std::lock_guard<std::mutex> const lock(mp);
+    std::lock_guard<std::mutex> lock(mp);
     jointhread = value;
 }
 
@@ -1430,11 +1430,11 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
     }
 
     // get srcSize to print progress
-    ssize_t const srcSize = getFileSize(src, "Program FPGA");
+    ssize_t srcSize = getFileSize(src, "Program FPGA");
 
     // create temp destination file
     char destfname[] = "/tmp/SLS_DET_MCB.XXXXXX";
-    int const dst = mkstemp(destfname); // create temporary file and open it in r/w
+    int dst = mkstemp(destfname); // create temporary file and open it in r/w
     if (dst == -1) {
         fclose(src);
         throw RuntimeError(std::string("Could not create destination file "
@@ -1466,7 +1466,7 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
         int oldProgress = 0;
         while (!feof(src)) {
             // print progress
-            int const progress = (int)(((double)(dstFilePos) / srcSize) * 100);
+            int progress = (int)(((double)(dstFilePos) / srcSize) * 100);
             if (oldProgress != progress) {
                 printf("%d%%\r", progress);
                 fflush(stdout);
@@ -1477,7 +1477,7 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
                 break;
             }
             // read source
-            int const s = fgetc(src);
+            int s = fgetc(src);
             if (s < 0) {
                 break;
             }
@@ -1547,13 +1547,13 @@ DetectorImpl::verifyUniqueDetHost(const std::string &name) {
     // extract port
     // C++17 could be auto [hostname, port] = ParseHostPort(name);
     auto res = ParseHostPort(name);
-    std::string const hostname = res.first;
+    std::string hostname = res.first;
     uint16_t port = res.second;
     if (port == 0) {
         port = DEFAULT_TCP_CNTRL_PORTNO;
     }
 
-    int const detSize = size();
+    int detSize = size();
     // mod not yet added
     std::vector<std::pair<std::string, uint16_t>> hosts(detSize + 1);
     hosts[detSize].first = hostname;
@@ -1573,8 +1573,8 @@ DetectorImpl::verifyUniqueRxHost(const std::string &name,
     // extract port
     // C++17 could be auto [hostname, port] = ParseHostPort(name);
     auto res = ParseHostPort(name);
-    std::string const hostname = res.first;
-    uint16_t const port = res.second;
+    std::string hostname = res.first;
+    uint16_t port = res.second;
 
     // hostname and port for given positions
     if (positions.empty() || (positions.size() == 1 && positions[0] == -1)) {
@@ -1669,7 +1669,7 @@ void DetectorImpl::validateROIs(const std::vector<defs::ROI> &rois) {
         if (roi.noRoi()) {
             throw RuntimeError("Invalid Roi of size 0. Roi: " + ToString(roi));
         }
-        bool const is2D = (modules[0]->getNumberOfChannels().y > 1 ? true : false);
+        bool is2D = (modules[0]->getNumberOfChannels().y > 1 ? true : false);
         if (roi.completeRoi()) {
             std::ostringstream oss;
             oss << "Did you mean the clear roi command (API: clearRxROI, cmd: "
@@ -1730,9 +1730,9 @@ defs::xy DetectorImpl::getPortGeometry() const {
 }
 
 defs::xy DetectorImpl::calculatePosition(int moduleIndex) const {
-    int const maxYMods = shm()->numberOfModules.y;
-    int const y = (moduleIndex % maxYMods);
-    int const x = (moduleIndex / maxYMods);
+    int maxYMods = shm()->numberOfModules.y;
+    int y = (moduleIndex % maxYMods);
+    int x = (moduleIndex / maxYMods);
     return defs::xy{x, y};
 }
 
@@ -1771,13 +1771,13 @@ void DetectorImpl::convertGlobalRoiToPortLevel(
         defs::ROI portRoi = moduleRoi;
         // Recalculate port ROI boundaries (split vertically or horizontally)
         if (portGeometry.x == 2) {
-            int const midX = (moduleRoi.xmin + moduleRoi.xmax) / 2;
+            int midX = (moduleRoi.xmin + moduleRoi.xmax) / 2;
             if (port == 0)
                 portRoi.xmax = midX;
             else
                 portRoi.xmin = midX + 1;
         } else if (portGeometry.y == 2) {
-            int const midY = (moduleRoi.ymin + moduleRoi.ymax) / 2;
+            int midY = (moduleRoi.ymin + moduleRoi.ymax) / 2;
             if (port == 0)
                 portRoi.ymax = midY;
             else
@@ -1823,7 +1823,7 @@ void DetectorImpl::setRxROI(const std::vector<defs::ROI> &args) {
     }
 
     validateROIs(args);
-    int const nPortsPerModule =
+    int nPortsPerModule =
         Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
             .tsquash("Inconsistent number of udp ports set up per module");
 
@@ -1845,7 +1845,7 @@ void DetectorImpl::setRxROI(const std::vector<defs::ROI> &args) {
 }
 
 void DetectorImpl::clearRxROI() {
-    int const nPortsPerModule =
+    int nPortsPerModule =
         Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
             .tsquash("Inconsistent number of udp ports set up per module");
     for (size_t iModule = 0; iModule < modules.size(); ++iModule) {
@@ -1890,7 +1890,7 @@ void DetectorImpl::getBadChannels(const std::string &fname,
 }
 
 void DetectorImpl::setBadChannels(const std::string &fname, Positions pos) {
-    std::vector<int> const list = sls::getChannelsFromFile(fname);
+    std::vector<int> list = sls::getChannelsFromFile(fname);
     if (list.empty()) {
         throw RuntimeError("Bad channel file is empty.");
     }
@@ -1913,8 +1913,8 @@ void DetectorImpl::setBadChannels(const std::vector<int> list, Positions pos) {
                                    std::to_string(badchannel) +
                                    " out of bounds.");
             }
-            int const ch = badchannel % nchan;
-            size_t const imod = badchannel / nchan;
+            int ch = badchannel % nchan;
+            size_t imod = badchannel / nchan;
             if (imod >= modules.size()) {
                 throw RuntimeError("Invalid bad channel list. " +
                                    std::to_string(badchannel) +
@@ -1935,86 +1935,317 @@ void DetectorImpl::setBadChannels(const std::vector<int> list, Positions pos) {
 }
 
 std::vector<std::string> DetectorImpl::getCtbDacNames() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named DACs only for CTB");
     return ctb_shm()->getDacNames();
 }
 
 void DetectorImpl::setCtbDacNames(const std::vector<std::string> &names) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named DACs only for CTB");
     ctb_shm()->setDacNames(names);
 }
 
 std::string DetectorImpl::getCtbDacName(defs::dacIndex i) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named DACs only for CTB");
     return ctb_shm()->getDacName(static_cast<int>(i));
 }
 
 void DetectorImpl::setCtbDacName(const defs::dacIndex index,
                                  const std::string &name) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named DACs only for CTB");
     ctb_shm()->setDacName(index, name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbAdcNames() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named ADCs only for CTB");
     return ctb_shm()->getAdcNames();
 }
 
 void DetectorImpl::setCtbAdcNames(const std::vector<std::string> &names) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named ADCs only for CTB");
     ctb_shm()->setAdcNames(names);
 }
 
 std::string DetectorImpl::getCtbAdcName(const int i) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named ADCs only for CTB");
     return ctb_shm()->getAdcName(i);
 }
 
 void DetectorImpl::setCtbAdcName(const int index, const std::string &name) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named ADCs only for CTB");
     ctb_shm()->setAdcName(index, name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbSignalNames() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named signals only for CTB");
     return ctb_shm()->getSignalNames();
 }
 
 void DetectorImpl::setCtbSignalNames(const std::vector<std::string> &names) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named signals only for CTB");
     ctb_shm()->setSignalNames(names);
 }
 
 std::string DetectorImpl::getCtbSignalName(const int i) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named signals only for CTB");
     return ctb_shm()->getSignalName(i);
 }
 
 void DetectorImpl::setCtbSignalName(const int index, const std::string &name) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named signals only for CTB");
     ctb_shm()->setSignalName(index, name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbPowerNames() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Powers only for CTB");
     return ctb_shm()->getPowerNames();
 }
 
 void DetectorImpl::setCtbPowerNames(const std::vector<std::string> &names) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Powers only for CTB");
     ctb_shm()->setPowerNames(names);
 }
 
 std::string DetectorImpl::getCtbPowerName(const defs::dacIndex i) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Powers only for CTB");
     return ctb_shm()->getPowerName(static_cast<int>(i - defs::V_POWER_A));
 }
 
 void DetectorImpl::setCtbPowerName(const defs::dacIndex index,
                                    const std::string &name) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Powers only for CTB");
     ctb_shm()->setPowerName(static_cast<int>(index - defs::V_POWER_A), name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbSlowADCNames() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Slow ADCs only for CTB");
     return ctb_shm()->getSlowADCNames();
 }
 
 void DetectorImpl::setCtbSlowADCNames(const std::vector<std::string> &names) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Slow ADCs only for CTB");
     ctb_shm()->setSlowADCNames(names);
 }
 
 std::string DetectorImpl::getCtbSlowADCName(const defs::dacIndex i) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Slow ADCs only for CTB");
     return ctb_shm()->getSlowADCName(static_cast<int>(i - defs::SLOW_ADC0));
 }
 
 void DetectorImpl::setCtbSlowADCName(const defs::dacIndex index,
                                      const std::string &name) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Named Slow ADCs only for CTB");
     ctb_shm()->setSlowADCName(static_cast<int>(index - defs::SLOW_ADC0), name);
 }
 
+int DetectorImpl::getRegisterDefinitionsCount() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    return ctb_shm()->getRegisterNamesCount();
+}
+
+void DetectorImpl::setRegisterDefinition(const std::string &name,
+                                         RegisterAddress addr) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    ctb_shm()->setRegisterName(name, addr);
+}
+
+bool DetectorImpl::hasRegisterDefinition(const std::string &name) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    return ctb_shm()->hasRegisterName(name);
+}
+
+bool DetectorImpl::hasRegisterDefinition(RegisterAddress addr) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    return ctb_shm()->hasRegisterAddress(addr);
+}
+
+RegisterAddress
+DetectorImpl::getRegisterAddress(const std::string &name) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    return ctb_shm()->getRegisterAddress(name);
+}
+
+std::string DetectorImpl::getRegisterName(RegisterAddress addr) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    return ctb_shm()->getRegisterName(addr);
+}
+
+void DetectorImpl::clearRegisterDefinitions() {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    ctb_shm()->clearRegisterNames();
+}
+
+void DetectorImpl::setRegisterDefinitions(
+    const std::map<std::string, RegisterAddress> &list) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    ctb_shm()->setRegisterNames(list);
+}
+
+std::map<std::string, RegisterAddress>
+DetectorImpl::getRegisterDefinitions() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Register Definitions only for CTB");
+    return ctb_shm()->getRegisterNames();
+}
+
+int DetectorImpl::getBitDefinitionsCount() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->getBitNamesCount();
+}
+
+void DetectorImpl::setBitDefinition(const std::string &name, BitAddress addr) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    ctb_shm()->setBitName(name, addr);
+}
+
+bool DetectorImpl::hasBitDefinition(const std::string &name) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->hasBitName(name);
+}
+
+bool DetectorImpl::hasBitDefinition(BitAddress addr) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->hasBitAddress(addr);
+}
+
+std::string DetectorImpl::toRegisterNameBitString(BitAddress addr) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->toRegisterNameBitString(addr);
+}
+
+BitAddress DetectorImpl::getBitAddress(const std::string &name) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->getBitAddress(name);
+}
+
+std::string DetectorImpl::getBitName(BitAddress addr) const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->getBitName(addr);
+}
+
+void DetectorImpl::clearBitDefinitions() {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    ctb_shm()->clearBitNames();
+}
+
+void DetectorImpl::setBitDefinitions(
+    const std::map<std::string, BitAddress> &list) {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    ctb_shm()->setBitNames(list);
+}
+
+std::map<std::string, BitAddress> DetectorImpl::getBitDefinitions() const {
+    if (!isChipTestBoard())
+        throw RuntimeError("Bit Definitions only for CTB");
+    return ctb_shm()->getBitNames();
+}
+
+Result<RegisterValue> DetectorImpl::readRegister(const std::string &reg_name,
+                                                 Positions pos) const {
+    if (!isChipTestBoard()) {
+        throw RuntimeError("Register Definitions only for CTB. Use hard coded "
+                           "values instead.");
+    }
+    auto addr = getRegisterAddress(reg_name);
+    return readRegister(addr, pos);
+}
+
+void DetectorImpl::writeRegister(const std::string &reg_name, RegisterValue val,
+                                 bool validate, Positions pos) {
+    if (!isChipTestBoard()) {
+        throw RuntimeError("Register Definitions only for CTB. Use hard coded "
+                           "values instead.");
+    }
+    auto addr = getRegisterAddress(reg_name);
+    writeRegister(addr, val, validate, pos);
+}
+
+void DetectorImpl::setBit(const std::string &bit_name, bool validate,
+                          Positions pos) {
+    if (!isChipTestBoard()) {
+        throw RuntimeError(
+            "Bit Definitions only for CTB. Use hard coded values instead.");
+    }
+    auto addr = getBitAddress(bit_name);
+    setBit(addr, validate, pos);
+}
+
+void DetectorImpl::clearBit(const std::string &bit_name, bool validate,
+                            Positions pos) {
+    if (!isChipTestBoard()) {
+        throw RuntimeError(
+            "Bit Definitions only for CTB. Use hard coded values instead.");
+    }
+    auto addr = getBitAddress(bit_name);
+    clearBit(addr, validate, pos);
+}
+
+Result<int> DetectorImpl::getBit(const std::string &bit_name,
+                                 Positions pos) const {
+    if (!isChipTestBoard()) {
+        throw RuntimeError(
+            "Bit Definitions only for CTB. Use hard coded values instead.");
+    }
+    auto addr = getBitAddress(bit_name);
+    return getBit(addr, pos);
+}
+
+Result<RegisterValue> DetectorImpl::readRegister(RegisterAddress addr,
+                                                 Positions pos) const {
+    return Parallel(&Module::readRegister, pos, addr);
+}
+
+void DetectorImpl::writeRegister(RegisterAddress addr, RegisterValue val,
+                                 bool validate, Positions pos) {
+    Parallel(&Module::writeRegister, pos, addr, val, validate);
+}
+
+void DetectorImpl::setBit(BitAddress addr, bool validate, Positions pos) {
+    Parallel(&Module::setBit, pos, addr, validate);
+}
+
+void DetectorImpl::clearBit(BitAddress addr, bool validate, Positions pos) {
+    Parallel(&Module::clearBit, pos, addr, validate);
+}
+
+Result<int> DetectorImpl::getBit(BitAddress addr, Positions pos) const {
+    return Parallel(&Module::getBit, pos, addr);
+}
+
 } // namespace sls

slsDetectorSoftware/src/DetectorImpl.h

@@ -90,7 +90,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<RT>> futures;
         futures.reserve(positions.size());
-        for (const size_t i : positions) {
+        for (size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -118,7 +118,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<RT>> futures;
         futures.reserve(positions.size());
-        for (const size_t i : positions) {
+        for (size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -145,7 +145,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<void>> futures;
         futures.reserve(positions.size());
-        for (const size_t i : positions) {
+        for (size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -170,7 +170,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<void>> futures;
         futures.reserve(positions.size());
-        for (const size_t i : positions) {
+        for (size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -183,6 +183,11 @@ class DetectorImpl : public virtual slsDetectorDefs {
 
     bool isAllPositions(Positions pos) const;
 
+    inline bool isChipTestBoard() const {
+        return (shm()->detType == defs::CHIPTESTBOARD ||
+                shm()->detType == defs::XILINX_CHIPTESTBOARD);
+    }
+
     /** set acquiring flag in shared memory */
     void setAcquiringFlag(bool flag);
 
@@ -328,6 +333,43 @@ class DetectorImpl : public virtual slsDetectorDefs {
     void setCtbSlowADCNames(const std::vector<std::string> &names);
     void setCtbSlowADCName(const defs::dacIndex index, const std::string &name);
 
+    int getRegisterDefinitionsCount() const;
+    void setRegisterDefinition(const std::string &name, RegisterAddress addr);
+    bool hasRegisterDefinition(const std::string &name) const;
+    bool hasRegisterDefinition(RegisterAddress addr) const;
+    RegisterAddress getRegisterAddress(const std::string &name) const;
+    std::string getRegisterName(RegisterAddress addr) const;
+    void clearRegisterDefinitions();
+    void
+    setRegisterDefinitions(const std::map<std::string, RegisterAddress> &list);
+    std::map<std::string, RegisterAddress> getRegisterDefinitions() const;
+    int getBitDefinitionsCount() const;
+    void setBitDefinition(const std::string &name, BitAddress addr);
+    bool hasBitDefinition(const std::string &name) const;
+    bool hasBitDefinition(BitAddress addr) const;
+    std::string toRegisterNameBitString(BitAddress addr) const;
+    BitAddress getBitAddress(const std::string &name) const;
+    std::string getBitName(BitAddress addr) const;
+    void clearBitDefinitions();
+    void setBitDefinitions(const std::map<std::string, BitAddress> &list);
+    std::map<std::string, BitAddress> getBitDefinitions() const;
+
+    Result<RegisterValue> readRegister(const std::string &reg_name,
+                                       Positions pos) const;
+    void writeRegister(const std::string &reg_name, RegisterValue val,
+                       bool validate, Positions pos);
+    void setBit(const std::string &bit_name, bool validate, Positions pos);
+    void clearBit(const std::string &bit_name, bool validate, Positions pos);
+    Result<int> getBit(const std::string &bit_name, Positions pos) const;
+
+    Result<RegisterValue> readRegister(RegisterAddress addr,
+                                       Positions pos = {}) const;
+    void writeRegister(RegisterAddress addr, RegisterValue val,
+                       bool validate = false, Positions pos = {});
+    void setBit(BitAddress addr, bool validate = false, Positions pos = {});
+    void clearBit(BitAddress addr, bool validate = false, Positions pos = {});
+    Result<int> getBit(BitAddress addr, Positions pos = {}) const;
+
   private:
     /**
      * Creates/open shared memory, initializes detector structure and members

slsDetectorSoftware/src/MapOnStack.h

@@ -0,0 +1,218 @@
+#pragma once
+
+// #include "sls/StaticVector.h"
+#include "sls/string_utils.h"
+
+#include <algorithm>
+#include <map>
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+namespace sls {
+
+template <size_t N> struct FixedString {
+    char data_[N]{};
+    constexpr FixedString() noexcept { memset(data_, 0, N); }
+    FixedString(const char (&s)[N]) {
+        if (N <= 1) {
+            throw std::runtime_error("FixedString cannot be empty");
+        }
+        strcpy_checked<N>(data_, s);
+    }
+    FixedString(const std::string &s) {
+        if (s.size() <= 1) {
+            throw std::runtime_error("FixedString cannot be empty");
+        }
+        strcpy_checked<N>(data_, s);
+    }
+    bool operator==(const FixedString &other) const noexcept {
+        return std::strncmp(data_, other.data_, N) == 0;
+    }
+    bool operator<(const FixedString &other) const noexcept {
+        return std::strncmp(data_, other.data_, N) < 0;
+    }
+    std::string str() const { return std::string(data_); }
+};
+
+template <typename Key, typename Value, size_t Capacity, bool Unique_Values>
+
+class MapOnStack {
+    // for shared memory use only trivially copyable types
+    static_assert(std::is_trivially_copyable_v<Key>);
+    static_assert(std::is_trivially_copyable_v<Value>);
+    static_assert(std::is_standard_layout_v<Key>);
+    static_assert(std::is_standard_layout_v<Value>);
+    static_assert(!std::is_pointer_v<Key>);
+    static_assert(!std::is_pointer_v<Value>);
+
+  public:
+    constexpr MapOnStack() noexcept = default;
+
+    constexpr size_t size() const noexcept { return current_size_; }
+    constexpr size_t capacity() const noexcept { return Capacity; }
+    constexpr bool empty() const noexcept { return current_size_ == 0; }
+    void clear() noexcept { current_size_ = 0; }
+
+    bool containsKey(const Key &key) const {
+        return lookupEntryByKey(key).has_value();
+    }
+
+    bool hasValue(const Value &value) const {
+        return lookupEntryByValue(value).has_value();
+    }
+
+    void addKeyOrSetValue(const Key &key, const Value &value) {
+        if (auto entry = findEntryByKey(key)) {
+            (*entry)->setValue(value);
+            return;
+        }
+        addEntry(key, value);
+    }
+
+    void addKey(const Key &key, const Value &value) { addEntry(key, value); }
+
+    void setValue(const Key &key, const Value &value) {
+        if (auto entry = findEntryByKey(key)) {
+            (*entry)->setValue(value);
+            return;
+        }
+        throw std::runtime_error("Key not found. Cannot set value.");
+    }
+
+    Value getValue(const Key &key) const {
+        auto val = lookupEntryByKey(key);
+        if (!val.has_value()) {
+            throw std::runtime_error("No entry found for key");
+        }
+        return val.value();
+    }
+
+    Key getKey(const Value &value) const {
+        auto key = lookupEntryByValue(value);
+        if (!key.has_value()) {
+            throw std::runtime_error("No entry found for value");
+        }
+        return key.value();
+    }
+
+    void setMap(const std::map<Key, Value> &list) {
+        if (list.size() >= Capacity) {
+            throw std::runtime_error("List size exceeds maximum Capacity");
+        }
+        clear();
+        for (const auto &[key, value] : list) {
+            addEntry(key, value);
+        }
+    }
+
+    std::map<Key, Value> getMap() const {
+        std::map<Key, Value> list;
+        for (size_t i = 0; i != current_size_; ++i)
+            list[data_[i].key()] = data_[i].value();
+        return list;
+    }
+
+  private:
+    struct Entry {
+        Key key_{};
+        Value value_{};
+        constexpr Entry() noexcept = default;
+        constexpr Entry(const Key &key, const Value &value)
+            : key_(key), value_(value) {}
+        constexpr Key key() const noexcept { return key_; }
+        constexpr Value value() const noexcept { return value_; }
+        constexpr void setValue(Value value) noexcept { value_ = value; }
+    };
+
+    Entry data_[Capacity];
+    size_t current_size_{0};
+    // StaticVector<Entry, Capacity> entries_;
+
+    std::optional<Entry *> findEntryByKey(const Key &key) {
+        auto it = std::find_if(data_, data_ + current_size_,
+                               [&key](Entry &e) { return (e.key() == key); });
+        if (it != data_ + current_size_)
+            return it;
+        return std::nullopt;
+    }
+
+    std::optional<const Entry *> findEntryByKey(const Key &key) const {
+        auto it =
+            std::find_if(data_, data_ + current_size_,
+                         [&key](const Entry &e) { return (e.key() == key); });
+        if (it != data_ + current_size_)
+            return it;
+        return std::nullopt;
+    }
+
+    std::optional<Entry *> findEntryByValue(Value value) {
+        if (!Unique_Values) {
+            throw std::runtime_error(
+                "Cannot lookup by value when unique values are not enforced.");
+        }
+        auto it =
+            std::find_if(data_, data_ + current_size_,
+                         [&value](Entry &e) { return e.value() == value; });
+        if (it != data_ + current_size_)
+            return it;
+        return std::nullopt;
+    }
+
+    std::optional<const Entry *> findEntryByValue(Value value) const {
+        if (!Unique_Values) {
+            throw std::runtime_error(
+                "Cannot lookup by value when unique values are not enforced.");
+        }
+        auto it = std::find_if(
+            data_, data_ + current_size_,
+            [&value](const Entry &e) { return e.value() == value; });
+        if (it != data_ + current_size_)
+            return it;
+        return std::nullopt;
+    }
+
+    std::optional<const Value> lookupEntryByKey(const Key &key) const {
+        auto entry = findEntryByKey(key);
+        return (entry ? std::optional<Value>((*entry)->value()) : std::nullopt);
+    }
+
+    std::optional<Key> lookupEntryByValue(Value value) const {
+        auto entry = findEntryByValue(value);
+        return (entry ? std::optional<Key>((*entry)->key()) : std::nullopt);
+    }
+
+    void checkDuplicateKey(const Key &key) const {
+        if (auto entry = findEntryByKey(key)) {
+            throw std::runtime_error(
+                "Key already exists. Cannot have duplicate keys.");
+        }
+    }
+
+    void checkDuplicateValue(Value value) const {
+        if (Unique_Values) {
+            if (auto entry = findEntryByValue(value)) {
+                throw std::runtime_error(
+                    "Value already assigned to another key '" +
+                    (*entry)->key().str() + "'. Cannot assign it again.");
+            }
+        }
+    }
+
+    void checkSize() const {
+        if (current_size_ >= Capacity) {
+            throw std::runtime_error("Maximum capacity reached");
+        }
+    }
+
+    void addEntry(const Key &key, const Value &value) {
+        checkSize();
+        checkDuplicateKey(key);
+        checkDuplicateValue(value);
+
+        data_[current_size_] = Entry(key, value);
+        ++(current_size_);
+    }
+};
+
+} // namespace sls

slsDetectorSoftware/src/Module.cpp

@@ -86,7 +86,7 @@ std::string Module::getControlServerLongVersion() const {
     }
     // throw with old server version (sends 8 bytes)
     catch (RuntimeError &e) {
-        std::string const emsg = std::string(e.what());
+        std::string emsg = std::string(e.what());
         if (emsg.find(F_GET_SERVER_VERSION) && emsg.find("8 bytes")) {
             throwDeprecatedServerVersion();
         }
@@ -95,7 +95,7 @@ std::string Module::getControlServerLongVersion() const {
 }
 
 void Module::throwDeprecatedServerVersion() const {
-    uint64_t const res = sendToDetectorStop<int64_t>(F_GET_SERVER_VERSION);
+    uint64_t res = sendToDetectorStop<int64_t>(F_GET_SERVER_VERSION);
     std::cout << std::endl;
     std::ostringstream os;
     os << "Detector Server (Control) version (0x" << std::hex << res
@@ -110,7 +110,7 @@ std::string Module::getStopServerLongVersion() const {
 }
 
 std::string Module::getDetectorServerVersion() const {
-    Version const v(getControlServerLongVersion());
+    Version v(getControlServerLongVersion());
     return v.concise();
 }
 
@@ -139,7 +139,7 @@ std::string Module::getReceiverLongVersion() const {
 }
 
 std::string Module::getReceiverSoftwareVersion() const {
-    Version const v(getReceiverLongVersion());
+    Version v(getReceiverLongVersion());
     return v.concise();
 }
 
@@ -183,7 +183,7 @@ slsDetectorDefs::xy Module::getNumberOfChannels() const {
 
 void Module::updateNumberOfModule(slsDetectorDefs::xy det) {
     shm()->numberOfModule = det;
-    int const args[2] = {shm()->numberOfModule.y, moduleIndex};
+    int args[2] = {shm()->numberOfModule.y, moduleIndex};
     sendToDetector(F_SET_POSITION, args, nullptr);
 }
 
@@ -218,14 +218,14 @@ void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
         throw RuntimeError("This energy " + std::to_string(e_eV) +
                            " not defined for this module!");
     }
-    bool const interpolate =
+    bool interpolate =
         std::all_of(shm()->trimEnergies.begin(), shm()->trimEnergies.end(),
                     [e_eV](const int &e) { return e != e_eV; });
 
     sls_detector_module myMod{shm()->detType};
 
     if (!interpolate) {
-        std::string const settingsfname = getTrimbitFilename(isettings, e_eV);
+        std::string settingsfname = getTrimbitFilename(isettings, e_eV);
         LOG(logDEBUG1) << "Settings File is " << settingsfname;
         myMod = readSettingsFile(settingsfname, trimbits);
     } else {
@@ -238,8 +238,8 @@ void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
                 break;
             }
         }
-        std::string const settingsfname1 = getTrimbitFilename(isettings, trim1);
-        std::string const settingsfname2 = getTrimbitFilename(isettings, trim2);
+        std::string settingsfname1 = getTrimbitFilename(isettings, trim1);
+        std::string settingsfname2 = getTrimbitFilename(isettings, trim2);
         LOG(logDEBUG1) << "Settings Files are " << settingsfname1 << " and "
                        << settingsfname2;
         auto myMod1 = readSettingsFile(settingsfname1, trimbits);
@@ -291,17 +291,17 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
     std::vector<sls_detector_module> myMods;
     for (size_t i = 0; i < energy.size(); ++i) {
         if (energy[i] == -1) {
-            sls_detector_module const mod = getModule();
+            sls_detector_module mod = getModule();
             myMods.push_back(mod);
             continue;
         }
 
-        sls_detector_module const mod{shm()->detType};
+        sls_detector_module mod{shm()->detType};
         myMods.push_back(mod);
 
         // don't interpolate
         if (shm()->trimEnergies.anyEqualTo(energy[i])) {
-            std::string const settingsfname =
+            std::string settingsfname =
                 getTrimbitFilename(isettings, energy[i]);
             LOG(logDEBUG1) << "Settings File is " << settingsfname;
             myMods[i] = readSettingsFile(settingsfname, trimbits);
@@ -335,8 +335,8 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
             LOG(logINFO) << "e_eV:" << energy[i] << " [" << trim1 << ", "
                          << trim2 << "]";
 
-            std::string const settingsfname1 = getTrimbitFilename(isettings, trim1);
-            std::string const settingsfname2 = getTrimbitFilename(isettings, trim2);
+            std::string settingsfname1 = getTrimbitFilename(isettings, trim1);
+            std::string settingsfname2 = getTrimbitFilename(isettings, trim2);
             LOG(logDEBUG1) << "Settings Files are " << settingsfname1 << " and "
                            << settingsfname2;
             auto myMod1 = readSettingsFile(settingsfname1, trimbits);
@@ -755,17 +755,17 @@ int Module::getClockDivider(int clkIndex) const {
 }
 
 void Module::setClockDivider(int clkIndex, int value) {
-    int const args[]{clkIndex, value};
+    int args[]{clkIndex, value};
     sendToDetector(F_SET_CLOCK_DIVIDER, args, nullptr);
 }
 
 int Module::getClockPhase(int clkIndex, bool inDegrees) const {
-    int const args[]{clkIndex, static_cast<int>(inDegrees)};
+    int args[]{clkIndex, static_cast<int>(inDegrees)};
     return sendToDetector<int>(F_GET_CLOCK_PHASE, args);
 }
 
 void Module::setClockPhase(int clkIndex, int value, bool inDegrees) {
-    int const args[]{clkIndex, value, static_cast<int>(inDegrees)};
+    int args[]{clkIndex, value, static_cast<int>(inDegrees)};
     sendToDetector(F_SET_CLOCK_PHASE, args, nullptr);
 }
 
@@ -778,22 +778,22 @@ int Module::getClockFrequency(int clkIndex) const {
 }
 
 void Module::setClockFrequency(int clkIndex, int value) {
-    int const args[]{clkIndex, value};
+    int args[]{clkIndex, value};
     sendToDetector(F_SET_CLOCK_FREQUENCY, args, nullptr);
 }
 
 int Module::getDAC(dacIndex index, bool mV) const {
-    int const args[]{static_cast<int>(index), static_cast<int>(mV), GET_FLAG};
+    int args[]{static_cast<int>(index), static_cast<int>(mV), GET_FLAG};
     return sendToDetector<int>(F_SET_DAC, args);
 }
 int Module::getDefaultDac(slsDetectorDefs::dacIndex index,
                           slsDetectorDefs::detectorSettings sett) {
-    int const args[]{static_cast<int>(index), static_cast<int>(sett)};
+    int args[]{static_cast<int>(index), static_cast<int>(sett)};
     return sendToDetector<int>(F_GET_DEFAULT_DAC, args);
 }
 void Module::setDefaultDac(slsDetectorDefs::dacIndex index, int defaultValue,
                            defs::detectorSettings sett) {
-    int const args[]{static_cast<int>(index), static_cast<int>(sett), defaultValue};
+    int args[]{static_cast<int>(index), static_cast<int>(sett), defaultValue};
     return sendToDetector(F_SET_DEFAULT_DAC, args, nullptr);
 }
 
@@ -803,7 +803,7 @@ void Module::resetToDefaultDacs(const bool hardReset) {
 }
 
 void Module::setDAC(int val, dacIndex index, bool mV) {
-    int const args[]{static_cast<int>(index), static_cast<int>(mV), val};
+    int args[]{static_cast<int>(index), static_cast<int>(mV), val};
     sendToDetector<int>(F_SET_DAC, args);
 }
 
@@ -844,13 +844,13 @@ int Module::getADC(dacIndex index) const {
 }
 
 int Module::getOnChipDAC(slsDetectorDefs::dacIndex index, int chipIndex) const {
-    int const args[]{static_cast<int>(index), chipIndex};
+    int args[]{static_cast<int>(index), chipIndex};
     return sendToDetector<int>(F_GET_ON_CHIP_DAC, args);
 }
 
 void Module::setOnChipDAC(slsDetectorDefs::dacIndex index, int chipIndex,
                           int value) {
-    int const args[]{static_cast<int>(index), chipIndex, value};
+    int args[]{static_cast<int>(index), chipIndex, value};
     sendToDetector(F_SET_ON_CHIP_DAC, args, nullptr);
 }
 
@@ -861,7 +861,7 @@ Module::getExternalSignalFlags(int signalIndex) const {
 }
 
 void Module::setExternalSignalFlags(int signalIndex, externalSignalFlag type) {
-    int const args[]{signalIndex, static_cast<int>(type)};
+    int args[]{signalIndex, static_cast<int>(type)};
     sendToDetector(F_SET_EXTERNAL_SIGNAL_FLAG, args, nullptr);
 }
 
@@ -1483,7 +1483,7 @@ void Module::setPartialFramesPadding(bool padding) {
 }
 
 int Module::getReceiverUDPSocketBufferSize() const {
-    int const arg = GET_FLAG;
+    int arg = GET_FLAG;
     return sendToReceiver<int>(F_RECEIVER_UDP_SOCK_BUF_SIZE, arg);
 }
 
@@ -1809,7 +1809,7 @@ int64_t Module::getRateCorrection() const {
 }
 
 void Module::setDefaultRateCorrection() {
-    int64_t const arg = -1;
+    int64_t arg = -1;
     sendToDetector(F_SET_RATE_CORRECT, arg, nullptr);
 }
 
@@ -1860,7 +1860,7 @@ bool Module::getActivate() const {
 }
 
 void Module::setActivate(const bool enable) {
-    int const arg = static_cast<int>(enable);
+    int arg = static_cast<int>(enable);
     auto retval = sendToDetector<int>(F_ACTIVATE, arg);
     sendToDetectorStop<int>(F_ACTIVATE, arg);
     if (shm()->useReceiverFlag) {
@@ -1894,7 +1894,7 @@ void Module::pulseChip(int n_pulses) {
 bool Module::getQuad() const { return sendToDetector<int>(F_GET_QUAD) != 0; }
 
 void Module::setQuad(const bool enable) {
-    int const value = enable ? 1 : 0;
+    int value = enable ? 1 : 0;
     sendToDetector(F_SET_QUAD, value, nullptr);
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_SET_RECEIVER_QUAD, value, nullptr);
@@ -1906,7 +1906,7 @@ bool Module::getDataStream(const portPosition port) const {
 }
 
 void Module::setDataStream(const portPosition port, const bool enable) {
-    int const args[]{static_cast<int>(port), static_cast<int>(enable)};
+    int args[]{static_cast<int>(port), static_cast<int>(enable)};
     sendToDetector(F_SET_DATASTREAM, args, nullptr);
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_RECEIVER_SET_DATASTREAM, args, nullptr);
@@ -2076,7 +2076,7 @@ std::array<int, 2> Module::getInjectChannel() const {
 
 void Module::setInjectChannel(const int offsetChannel,
                               const int incrementChannel) {
-    int const args[]{offsetChannel, incrementChannel};
+    int args[]{offsetChannel, incrementChannel};
     sendToDetector(F_SET_INJECT_CHANNEL, args, nullptr);
 }
 
@@ -2331,18 +2331,18 @@ slsDetectorDefs::vetoAlgorithm Module::getVetoAlgorithm(
 void Module::setVetoAlgorithm(
     const slsDetectorDefs::vetoAlgorithm alg,
     const slsDetectorDefs::streamingInterface interface) {
-    int const args[]{static_cast<int>(alg), static_cast<int>(interface)};
+    int args[]{static_cast<int>(alg), static_cast<int>(interface)};
     sendToDetector(F_SET_VETO_ALGORITHM, args, nullptr);
 }
 
 int Module::getADCConfiguration(const int chipIndex, const int adcIndex) const {
-    int const args[]{chipIndex, adcIndex};
+    int args[]{chipIndex, adcIndex};
     return sendToDetector<int>(F_GET_ADC_CONFIGURATION, args);
 }
 
 void Module::setADCConfiguration(const int chipIndex, const int adcIndex,
                                  int value) {
-    int const args[]{chipIndex, adcIndex, value};
+    int args[]{chipIndex, adcIndex, value};
     sendToDetector(F_SET_ADC_CONFIGURATION, args, nullptr);
 }
 
@@ -2417,7 +2417,7 @@ bool Module::getInterpolation() const {
 
 void Module::setInterpolation(const bool enable) {
     sendToDetector(F_SET_INTERPOLATION, static_cast<int>(enable), nullptr);
-    int const mask = getCounterMask();
+    int mask = getCounterMask();
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_RECEIVER_SET_COUNTER_MASK, mask, nullptr);
     }
@@ -2575,10 +2575,11 @@ void Module::setReceiverDbitList(std::vector<int> list) {
         }
     }
     auto r = stableRemoveDuplicates(list);
-    if(r)
+    if (r) {
         LOG(logWARNING) << "Removed duplicated from receiver dbit list";
+    }
 
-    StaticVector<int, MAX_RX_DBIT> const arg = list;
+    StaticVector<int, MAX_RX_DBIT> arg = list;
     sendToReceiver(F_SET_RECEIVER_DBIT_LIST, arg, nullptr);
 }
 
@@ -2600,7 +2601,7 @@ void Module::setReceiverDbitReorder(bool reorder) {
 }
 
 void Module::setDigitalIODelay(uint64_t pinMask, int delay) {
-    uint64_t const args[]{pinMask, static_cast<uint64_t>(delay)};
+    uint64_t args[]{pinMask, static_cast<uint64_t>(delay)};
     sendToDetector(F_DIGITAL_IO_DELAY, args, nullptr);
 }
 
@@ -2657,57 +2658,57 @@ void Module::setPatternIOControl(uint64_t word) {
 }
 
 uint64_t Module::getPatternWord(int addr) const {
-    uint64_t const args[]{static_cast<uint64_t>(addr),
+    uint64_t args[]{static_cast<uint64_t>(addr),
                     static_cast<uint64_t>(GET_FLAG)};
     return sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args);
 }
 
 void Module::setPatternWord(int addr, uint64_t word) {
-    uint64_t const args[]{static_cast<uint64_t>(addr), word};
+    uint64_t args[]{static_cast<uint64_t>(addr), word};
     sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args);
 }
 
 std::array<int, 2> Module::getPatternLoopAddresses(int level) const {
-    int const args[]{level, GET_FLAG, GET_FLAG};
+    int args[]{level, GET_FLAG, GET_FLAG};
     std::array<int, 2> retvals{};
     sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals);
     return retvals;
 }
 
 void Module::setPatternLoopAddresses(int level, int start, int stop) {
-    int const args[]{level, start, stop};
+    int args[]{level, start, stop};
     std::array<int, 2> retvals{};
     sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals);
 }
 
 int Module::getPatternLoopCycles(int level) const {
-    int const args[]{level, GET_FLAG};
+    int args[]{level, GET_FLAG};
     return sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args);
 }
 
 void Module::setPatternLoopCycles(int level, int n) {
-    int const args[]{level, n};
+    int args[]{level, n};
     sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args);
 }
 
 int Module::getPatternWaitAddr(int level) const {
-    int const args[]{level, GET_FLAG};
+    int args[]{level, GET_FLAG};
     return sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args);
 }
 
 void Module::setPatternWaitAddr(int level, int addr) {
-    int const args[]{level, addr};
+    int args[]{level, addr};
     sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args);
 }
 
 uint64_t Module::getPatternWaitClocks(int level) const {
-    uint64_t const args[]{static_cast<uint64_t>(level),
+    uint64_t args[]{static_cast<uint64_t>(level),
                     static_cast<uint64_t>(GET_FLAG)};
     return sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_CLOCKS, args);
 }
 
 void Module::setPatternWaitClocks(int level, uint64_t t) {
-    uint64_t const args[]{static_cast<uint64_t>(level), t};
+    uint64_t args[]{static_cast<uint64_t>(level), t};
     sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_CLOCKS, args);
 }
 
@@ -2715,7 +2716,7 @@ uint64_t Module::getPatternWaitInterval(int level) const {
     return sendToDetector<uint64_t>(F_GET_PATTERN_WAIT_INTERVAL, level);
 }
 void Module::setPatternWaitInterval(int level, uint64_t t) {
-    uint64_t const args[]{static_cast<uint64_t>(level), t};
+    uint64_t args[]{static_cast<uint64_t>(level), t};
     sendToDetector(F_SET_PATTERN_WAIT_INTERVAL, args, nullptr);
 }
 
@@ -2914,29 +2915,30 @@ void Module::setUpdateMode(const bool updatemode) {
                  << "): Update Mode set to " << updatemode << "!";
 }
 
-uint32_t Module::readRegister(uint32_t addr) const {
-    return sendToDetectorStop<uint32_t>(F_READ_REGISTER, addr);
+RegisterValue Module::readRegister(RegisterAddress addr) const {
+    return sendToDetectorStop<RegisterValue>(F_READ_REGISTER, addr.value());
 }
 
-void Module::writeRegister(uint32_t addr, uint32_t val, bool validate) {
-    uint32_t const args[]{addr, val, static_cast<uint32_t>(validate)};
+void Module::writeRegister(RegisterAddress addr, RegisterValue val,
+                           bool validate) {
+    uint32_t args[]{addr.value(), val.value(), static_cast<uint32_t>(validate)};
     return sendToDetectorStop(F_WRITE_REGISTER, args, nullptr);
 }
 
-void Module::setBit(uint32_t addr, int n, bool validate) {
-    uint32_t const args[] = {addr, static_cast<uint32_t>(n),
+void Module::setBit(BitAddress bitAddr, bool validate) {
+    uint32_t args[] = {bitAddr.address().value(), bitAddr.bitPosition(),
                        static_cast<uint32_t>(validate)};
     sendToDetectorStop(F_SET_BIT, args, nullptr);
 }
 
-void Module::clearBit(uint32_t addr, int n, bool validate) {
-    uint32_t const args[] = {addr, static_cast<uint32_t>(n),
+void Module::clearBit(BitAddress bitAddr, bool validate) {
+    uint32_t args[] = {bitAddr.address().value(), bitAddr.bitPosition(),
                        static_cast<uint32_t>(validate)};
     sendToDetectorStop(F_CLEAR_BIT, args, nullptr);
 }
 
-int Module::getBit(uint32_t addr, int n) {
-    uint32_t const args[2] = {addr, static_cast<uint32_t>(n)};
+int Module::getBit(BitAddress bitAddr) const {
+    uint32_t args[2] = {bitAddr.address().value(), bitAddr.bitPosition()};
     return sendToDetectorStop<int>(F_GET_BIT, args);
 }
 
@@ -2945,7 +2947,7 @@ void Module::executeFirmwareTest() { sendToDetector(F_SET_FIRMWARE_TEST); }
 void Module::executeBusTest() { sendToDetector(F_SET_BUS_TEST); }
 
 void Module::writeAdcRegister(uint32_t addr, uint32_t val) {
-    uint32_t const args[]{addr, val};
+    uint32_t args[]{addr, val};
     sendToDetector(F_WRITE_ADC_REG, args, nullptr);
 }
 
@@ -3449,7 +3451,7 @@ void Module::initializeModuleStructure(detectorType type) {
     shm()->stoppedFlag = false;
 
     // get the Module parameters based on type
-    detParameters const parameters{type};
+    detParameters parameters{type};
     shm()->nChan.x = parameters.nChanX;
     shm()->nChan.y = parameters.nChanY;
     shm()->nChip.x = parameters.nChipX;
@@ -3463,12 +3465,12 @@ void Module::initialDetectorServerChecks() {
 }
 
 void Module::checkDetectorVersionCompatibility() {
-    std::string const detServers[2] = {getControlServerLongVersion(),
+    std::string detServers[2] = {getControlServerLongVersion(),
                                  getStopServerLongVersion()};
     for (int i = 0; i != 2; ++i) {
         // det and client (sem. versioning)
-        Version const det(detServers[i]);
-        Version const client(APILIB);
+        Version det(detServers[i]);
+        Version client(APILIB);
         if (det.hasSemanticVersioning() && client.hasSemanticVersioning()) {
             if (!det.isBackwardCompatible(client)) {
                 std::ostringstream oss;
@@ -3482,7 +3484,7 @@ void Module::checkDetectorVersionCompatibility() {
         }
         // comparing dates(exact match to expected)
         else {
-            Version const expectedDetector(getDetectorAPI());
+            Version expectedDetector(getDetectorAPI());
             if (det != expectedDetector) {
                 std::ostringstream oss;
                 oss << "Detector (" << (i == 0 ? "Control" : "Stop")
@@ -3521,8 +3523,8 @@ const std::string Module::getDetectorAPI() const {
 
 void Module::checkReceiverVersionCompatibility() {
     // rxr and client (sem. versioning)
-    Version const rxr(getReceiverLongVersion());
-    Version const client(APILIB);
+    Version rxr(getReceiverLongVersion());
+    Version client(APILIB);
     if (rxr.hasSemanticVersioning() && client.hasSemanticVersioning()) {
         if (!rxr.isBackwardCompatible(client)) {
             std::ostringstream oss;
@@ -3535,7 +3537,7 @@ void Module::checkReceiverVersionCompatibility() {
     }
     // comparing dates(exact match to expected)
     else {
-        Version const expectedReceiver(APIRECEIVER);
+        Version expectedReceiver(APIRECEIVER);
         if (rxr != expectedReceiver) {
             std::ostringstream oss;
             oss << "Receiver version (" << rxr.getDate()
@@ -3666,7 +3668,7 @@ void Module::sendModule(sls_detector_module *myMod, ClientSocket &client) {
     ts += n;
     LOG(level) << "channels sent. " << n << " bytes";
 
-    int const expectedBytesSent = sizeof(sls_detector_module) - sizeof(myMod->dacs) -
+    int expectedBytesSent = sizeof(sls_detector_module) - sizeof(myMod->dacs) -
                             sizeof(myMod->chanregs) +
                             (myMod->ndac * sizeof(int)) +
                             (myMod->nchan * sizeof(int));
@@ -3732,7 +3734,7 @@ sls_detector_module Module::interpolateTrim(sls_detector_module *a,
             "Interpolation of Trim values not implemented for this detector!");
     }
 
-    sls_detector_module const myMod{shm()->detType};
+    sls_detector_module myMod{shm()->detType};
 
     // create copy and interpolate dac lists
     std::vector<int> dacs_to_copy, dacs_to_interpolate;
@@ -3878,7 +3880,7 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
 
     // mythen3 (dacs, trimbits)
     else if (shm()->detType == MYTHEN3) {
-        int const expected_size = sizeof(int) * myMod.ndac +
+        int expected_size = sizeof(int) * myMod.ndac +
                             sizeof(int) * myMod.nchan + sizeof(myMod.reg);
         if (file_size != expected_size) {
             throw RuntimeError("The size of the settings file: " + fname +
@@ -3957,7 +3959,7 @@ void Module::sendProgram(bool blackfin, std::vector<char> buffer,
     client.Send(filesize);
 
     // send checksum
-    std::string const checksum = md5_calculate_checksum(buffer.data(), filesize);
+    std::string checksum = md5_calculate_checksum(buffer.data(), filesize);
     LOG(logDEBUG1) << "Checksum:" << checksum;
     char cChecksum[MAX_STR_LENGTH] = {0};
     strcpy(cChecksum, checksum.c_str());

slsDetectorSoftware/src/Module.h

@@ -5,6 +5,7 @@
 #include "sls/ClientSocket.h"
 #include "sls/Pattern.h"
 #include "sls/StaticVector.h"
+#include "sls/bit_utils.h"
 #include "sls/logger.h"
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
@@ -579,11 +580,11 @@ class Module : public virtual slsDetectorDefs {
     void rebootController();
     bool getUpdateMode() const;
     void setUpdateMode(const bool updatemode);
-    uint32_t readRegister(uint32_t addr) const;
-    void writeRegister(uint32_t addr, uint32_t val, bool validate);
-    void setBit(uint32_t addr, int n, bool validate);
-    void clearBit(uint32_t addr, int n, bool validate);
-    int getBit(uint32_t addr, int n);
+    RegisterValue readRegister(RegisterAddress addr) const;
+    void writeRegister(RegisterAddress addr, RegisterValue val, bool validate);
+    void setBit(BitAddress bitAddr, bool validate);
+    void clearBit(BitAddress bitAddr, bool validate);
+    int getBit(BitAddress bitAddr) const;
     void executeFirmwareTest();
     void executeBusTest();
     void writeAdcRegister(uint32_t addr, uint32_t val);

slsDetectorSoftware/src/Pattern.cpp

@@ -114,14 +114,14 @@ size_t Pattern::load(const std::string &fname) {
                 it, std::istream_iterator<std::string>());
 
             std::string cmd = args[0];
-            int const nargs = args.size() - 1;
+            int nargs = args.size() - 1;
 
             if (cmd == "patword") {
                 if (nargs != 2) {
                     throw RuntimeError("Invalid arguments for " +
                                        ToString(args));
                 }
-                uint32_t const addr = StringTo<uint32_t>(args[1]);
+                uint32_t addr = StringTo<uint32_t>(args[1]);
                 if (addr >= MAX_PATTERN_LENGTH) {
                     throw RuntimeError("Invalid address for " + ToString(args));
                 }
@@ -162,8 +162,8 @@ size_t Pattern::load(const std::string &fname) {
                     throw RuntimeError("Invalid Pattern level. Options 0-" +
                                        std::to_string(MAX_PATTERN_LEVELS - 1));
                 }
-                int const loop1 = StringTo<uint32_t>(args[iArg++]);
-                int const loop2 = StringTo<uint32_t>(args[iArg++]);
+                int loop1 = StringTo<uint32_t>(args[iArg++]);
+                int loop2 = StringTo<uint32_t>(args[iArg++]);
                 pat->startloop[level] = loop1;
                 pat->stoploop[level] = loop2;
             } else if (cmd == "patnloop0" || cmd == "patnloop1" ||

slsDetectorSoftware/src/SharedMemory.h

@@ -28,9 +28,11 @@
 // ********************** Defines for shared memory. **********************
 // WARNING! before chaning these search the codebase for their usage!
 
+// date when IsValid boolean introduced into every shm structure
+// (to look out for shm that still exists due to other mapped resources)
 #define SHM_IS_VALID_CHECK_VERSION 0x250820
 
-//Max shared memory name length in macOS is 31 characters
+// Max shared memory name length in macOS is 31 characters
 #ifdef __APPLE__
 #define SHM_DETECTOR_PREFIX "/sls_"
 #define SHM_MODULE_PREFIX   "_mod_"
@@ -46,7 +48,6 @@ namespace sls {
 
 class CtbConfig;
 
-
 template <typename T, typename U> constexpr bool is_type() {
     return std::is_same_v<std::decay_t<U>, T>;
 }
@@ -94,17 +95,16 @@ template <typename T> class SharedMemory {
             unmapSharedMemory();
     }
 
+    /** memory is valid if it has the IsValid flag and is true */
     bool memoryHasValidFlag() const {
         if (shared_struct == nullptr) {
             throw SharedMemoryError(
                 "Shared memory not mapped. Cannot check validity.");
         }
-        // CtbConfig did not have shmversion before, so exact value check
-        if constexpr (is_type<CtbConfig, T>()) {
-            if (shared_struct->shmversion == SHM_IS_VALID_CHECK_VERSION) {
-                return true;
-            }
-        } else if (shared_struct->shmversion >= SHM_IS_VALID_CHECK_VERSION) {
+        // CtbConfig also works (shmversion didnt exist prior, but it would read
+        // "20" = length size) so shmversion should always be >= isValid
+        // introduced date (0x250820)
+        if (shared_struct->shmversion >= SHM_IS_VALID_CHECK_VERSION) {
             return true;
         }
         return false;
@@ -154,7 +154,7 @@ template <typename T> class SharedMemory {
     std::string getName() const { return name; }
 
     bool exists() {
-        const int tempfd = shm_open(name.c_str(), O_RDWR, 0);
+        int tempfd = shm_open(name.c_str(), O_RDWR, 0);
         if ((tempfd < 0) && (errno == ENOENT)) {
             return false;
         }
@@ -163,7 +163,7 @@ template <typename T> class SharedMemory {
     }
 
     void createSharedMemory() {
-        const int fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR,
+        int fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR,
                           S_IRUSR | S_IWUSR);
         if (fd < 0) {
             std::string msg =
@@ -184,9 +184,9 @@ template <typename T> class SharedMemory {
     }
 
     void openSharedMemory(bool verifySize) {
-        const int fd = shm_open(name.c_str(), O_RDWR, 0);
+        int fd = shm_open(name.c_str(), O_RDWR, 0);
         if (fd < 0) {
-            const std::string msg = "Open existing shared memory " + name +
+            std::string msg = "Open existing shared memory " + name +
                               " failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
@@ -198,7 +198,7 @@ template <typename T> class SharedMemory {
     void unmapSharedMemory() {
         if (shared_struct != nullptr) {
             if (munmap(shared_struct, sizeof(T)) < 0) {
-                const std::string msg = "Unmapping shared memory " + name +
+                std::string msg = "Unmapping shared memory " + name +
                                   " failed: " + strerror(errno);
                 throw SharedMemoryError(msg);
             }
@@ -213,7 +213,7 @@ template <typename T> class SharedMemory {
             // silent exit if shm did not exist anyway
             if (errno == ENOENT)
                 return;
-            const std::string msg =
+            std::string msg =
                 "Free Shared Memory " + name + " Failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
@@ -244,7 +244,7 @@ template <typename T> class SharedMemory {
 
         std::string shm_name = ss.str();
         if (shm_name.length() > NAME_MAX_LENGTH) {
-            const std::string msg =
+            std::string msg =
                 "Shared memory initialization failed. " + shm_name + " has " +
                 std::to_string(shm_name.length()) + " characters. \n" +
                 "Maximum is " + std::to_string(NAME_MAX_LENGTH) +
@@ -262,7 +262,7 @@ template <typename T> class SharedMemory {
             mmap(nullptr, sizeof(T), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
         close(fd);
         if (addr == MAP_FAILED) {
-            const std::string msg =
+            std::string msg =
                 "Mapping shared memory " + name + " failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
@@ -272,22 +272,23 @@ template <typename T> class SharedMemory {
     void checkSize(int fd) {
         struct stat sb;
         if (fstat(fd, &sb) < 0) {
-            const std::string msg = "Could not verify existing shared memory " +
+            std::string msg = "Could not verify existing shared memory " +
                               name + " size match " +
                               "(could not fstat): " + strerror(errno);
             close(fd);
             throw SharedMemoryError(msg);
         }
 
-        #ifdef __APPLE__
-        // On macOS, fstat returns the allocated size and not the requested size.
-        // This means we can't check for size since we always get for example 16384 bytes.
+#ifdef __APPLE__
+        // On macOS, fstat returns the allocated size and not the requested
+        // size. This means we can't check for size since we always get for
+        // example 16384 bytes.
         return;
-        #endif
+#endif
         auto actual_size = static_cast<size_t>(sb.st_size);
         auto expected_size = sizeof(T);
         if (actual_size != expected_size) {
-            const std::string msg =
+            std::string msg =
                 "Existing shared memory " + name + " size does not match. " +
                 "Expected " + std::to_string(expected_size) + ", found " +
                 std::to_string(actual_size) +

slsDetectorSoftware/src/inferAction.cpp

@@ -400,6 +400,10 @@ int InferAction::chipversion() {
 
 int InferAction::clearbit() {
 
+    if (args.size() == 1) {
+        return slsDetectorDefs::PUT_ACTION;
+    }
+
     if (args.size() == 2) {
         return slsDetectorDefs::PUT_ACTION;
     }
@@ -788,6 +792,66 @@ int InferAction::defaultpattern() {
     }
 }
 
+int InferAction::define_bit() {
+
+    if (args.size() == 1) {
+        return slsDetectorDefs::GET_ACTION;
+    }
+
+    if (args.size() == 2) {
+        return slsDetectorDefs::GET_ACTION;
+    }
+
+    if (args.size() == 3) {
+        return slsDetectorDefs::PUT_ACTION;
+    }
+
+    else {
+
+        throw RuntimeError("Could not infer action: Wrong number of arguments");
+    }
+}
+
+int InferAction::define_reg() {
+
+    if (args.size() == 1) {
+        return slsDetectorDefs::GET_ACTION;
+    }
+
+    if (args.size() == 2) {
+        return slsDetectorDefs::PUT_ACTION;
+    }
+
+    else {
+
+        throw RuntimeError("Could not infer action: Wrong number of arguments");
+    }
+}
+
+int InferAction::definelist_bit() {
+
+    if (args.size() == 0) {
+        return slsDetectorDefs::GET_ACTION;
+    }
+
+    else {
+
+        throw RuntimeError("Could not infer action: Wrong number of arguments");
+    }
+}
+
+int InferAction::definelist_reg() {
+
+    if (args.size() == 0) {
+        return slsDetectorDefs::GET_ACTION;
+    }
+
+    else {
+
+        throw RuntimeError("Could not infer action: Wrong number of arguments");
+    }
+}
+
 int InferAction::delay() {
 
     if (args.size() == 0) {
@@ -1498,6 +1562,10 @@ int InferAction::gates() {
 
 int InferAction::getbit() {
 
+    if (args.size() == 1) {
+        return slsDetectorDefs::GET_ACTION;
+    }
+
     if (args.size() == 2) {
         return slsDetectorDefs::GET_ACTION;
     }
@@ -3055,6 +3123,10 @@ int InferAction::serialnumber() {
 
 int InferAction::setbit() {
 
+    if (args.size() == 1) {
+        return slsDetectorDefs::PUT_ACTION;
+    }
+
     if (args.size() == 2) {
         return slsDetectorDefs::PUT_ACTION;
     }

slsDetectorSoftware/src/inferAction.h

@@ -62,6 +62,10 @@ class InferAction {
     int dbitpipeline();
     int defaultdac();
     int defaultpattern();
+    int define_bit();
+    int define_reg();
+    int definelist_bit();
+    int definelist_reg();
     int delay();
     int delayl();
     int detectorserverversion();
@@ -394,6 +398,10 @@ class InferAction {
         {"dbitpipeline", &InferAction::dbitpipeline},
         {"defaultdac", &InferAction::defaultdac},
         {"defaultpattern", &InferAction::defaultpattern},
+        {"define_bit", &InferAction::define_bit},
+        {"define_reg", &InferAction::define_reg},
+        {"definelist_bit", &InferAction::definelist_bit},
+        {"definelist_reg", &InferAction::definelist_reg},
         {"delay", &InferAction::delay},
         {"delayl", &InferAction::delayl},
         {"detectorserverversion", &InferAction::detectorserverversion},

slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp

@@ -29,18 +29,18 @@ TEST_CASE("jungfrau_or_moench_acquire_check_file_size",
         auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash(
             "inconsistent number of udp interfaces");
 
-        int const num_frames_to_acquire = 2;
+        int num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters const par(det_type);
-            int const bytes_per_pixel = det.getDynamicRange().squash() / 8;
+            detParameters par(det_type);
+            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
             // if 2 udp interfaces, data split into half
-            size_t const expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
+            size_t expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
                                           par.nChipY * bytes_per_pixel) /
                                          num_udp_interfaces;
-            testFileInfo const test_file_info;
+            testFileInfo test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -55,23 +55,23 @@ TEST_CASE("eiger_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::EIGER) {
 
-        int const dynamic_range = det.getDynamicRange().squash();
+        int dynamic_range = det.getDynamicRange().squash();
         if (dynamic_range != 16) {
             throw RuntimeError(
                 "Eiger detector must have dynamic range 16 to test");
         }
-        int const num_frames_to_acquire = 2;
+        int num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters const par(det_type);
+            detParameters par(det_type);
             // data split into half due to 2 udp interfaces per half module
-            int const num_chips = (par.nChipX / 2);
-            int const bytes_per_pixel = (dynamic_range / 8);
-            size_t const expected_image_size =
+            int num_chips = (par.nChipX / 2);
+            int bytes_per_pixel = (dynamic_range / 8);
+            size_t expected_image_size =
                 par.nChanX * par.nChanY * num_chips * bytes_per_pixel;
-            testFileInfo const test_file_info;
+            testFileInfo test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -86,25 +86,25 @@ TEST_CASE("mythen3_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::MYTHEN3) {
 
-        int const dynamic_range = det.getDynamicRange().squash();
-        int const counter_mask = det.getCounterMask().squash();
+        int dynamic_range = det.getDynamicRange().squash();
+        int counter_mask = det.getCounterMask().squash();
         if (dynamic_range != 16 && counter_mask != 0x3) {
             throw RuntimeError("Mythen3 detector must have dynamic range 16 "
                                "and counter mask 0x3 to test");
         }
-        int const num_counters = __builtin_popcount(counter_mask);
-        int const num_frames_to_acquire = 2;
+        int num_counters = __builtin_popcount(counter_mask);
+        int num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters const par(det_type);
-            int const bytes_per_pixel = dynamic_range / 8;
-            int const num_channels_per_counter = par.nChanX / 3;
-            size_t const expected_image_size = num_channels_per_counter *
+            detParameters par(det_type);
+            int bytes_per_pixel = dynamic_range / 8;
+            int num_channels_per_counter = par.nChanX / 3;
+            size_t expected_image_size = num_channels_per_counter *
                                          num_counters * par.nChipX *
                                          bytes_per_pixel;
-            testFileInfo const test_file_info;
+            testFileInfo test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -119,16 +119,16 @@ TEST_CASE("gotthard2_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::GOTTHARD2) {
 
-        int const num_frames_to_acquire = 2;
+        int num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters const par(det_type);
-            int const bytes_per_pixel = det.getDynamicRange().squash() / 8;
-            size_t const expected_image_size =
+            detParameters par(det_type);
+            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
+            size_t expected_image_size =
                 par.nChanX * par.nChipX * bytes_per_pixel;
-            testFileInfo const test_file_info;
+            testFileInfo test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -143,9 +143,9 @@ void test_ctb_file_size_with_acquire(Detector &det, Caller &caller,
     create_files_for_acquire(det, caller, num_frames, test_info);
 
     // check file size (assuming local pc)
-    uint64_t const expected_image_size =
+    uint64_t expected_image_size =
         calculate_ctb_image_size(test_info, isXilinxCtb).first;
-    testFileInfo const test_file_info;
+    testFileInfo test_file_info;
     REQUIRE_NOTHROW(test_acquire_binary_file_size(test_file_info, num_frames,
                                                   expected_image_size));
 }
@@ -158,8 +158,8 @@ TEST_CASE("ctb_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        bool const isXilinxCtb = (det_type == defs::XILINX_CHIPTESTBOARD);
-        int const num_frames_to_acquire = 2;
+        bool isXilinxCtb = (det_type == defs::XILINX_CHIPTESTBOARD);
+        int num_frames_to_acquire = 2;
         // all the test cases
         {
             testCtbAcquireInfo test_ctb_config{};

slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp

@@ -26,8 +26,8 @@ TEST_CASE("dacname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex const ind = static_cast<defs::dacIndex>(2);
-        std::string const str_dac_index = "2";
+        defs::dacIndex ind = static_cast<defs::dacIndex>(2);
+        std::string str_dac_index = "2";
         auto prev = det.getDacName(ind);
 
         // 1 arg throw
@@ -61,8 +61,8 @@ TEST_CASE("dacindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex const ind = static_cast<defs::dacIndex>(2);
-        std::string const str_dac_index = "2";
+        defs::dacIndex ind = static_cast<defs::dacIndex>(2);
+        std::string str_dac_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("dacindex", {"2", "2"}, -1, PUT));
@@ -120,8 +120,8 @@ TEST_CASE("adcname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int const ind = 2;
-        std::string const str_adc_index = "2";
+        int ind = 2;
+        std::string str_adc_index = "2";
         auto prev = det.getAdcName(ind);
 
         // 1 arg throw
@@ -155,8 +155,8 @@ TEST_CASE("adcindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int const ind = 2;
-        std::string const str_adc_index = "2";
+        int ind = 2;
+        std::string str_adc_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("adcindex", {"2", "2"}, -1, PUT));
@@ -214,8 +214,8 @@ TEST_CASE("signalname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int const ind = 2;
-        std::string const str_signal_index = "2";
+        int ind = 2;
+        std::string str_signal_index = "2";
         auto prev = det.getSignalName(ind);
 
         // 1 arg throw
@@ -249,8 +249,8 @@ TEST_CASE("signalindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int const ind = 2;
-        std::string const str_signal_index = "2";
+        int ind = 2;
+        std::string str_signal_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("signalindex", {"2", "2"}, -1, PUT));
@@ -309,8 +309,8 @@ TEST_CASE("powername", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
-        std::string const str_power_index = "2";
+        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
+        std::string str_power_index = "2";
         auto prev = det.getPowerName(ind);
 
         // 1 arg throw
@@ -344,8 +344,8 @@ TEST_CASE("powerindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
-        std::string const str_power_index = "2";
+        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
+        std::string str_power_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("powerindex", {"2", "2"}, -1, PUT));
@@ -430,8 +430,8 @@ TEST_CASE("slowadcname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
-        std::string const str_slowadc_index = "2";
+        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
+        std::string str_slowadc_index = "2";
         auto prev = det.getSlowADCName(ind);
 
         // 1 arg throw
@@ -466,8 +466,8 @@ TEST_CASE("slowadcindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
-        std::string const str_slowadc_index = "2";
+        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
+        std::string str_slowadc_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("slowadcindex", {"2", "2"}, -1, PUT));
@@ -1030,14 +1030,12 @@ TEST_CASE("v_abcd", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    std::vector<std::string> cmds{"v_a", "v_b", "v_c", "v_d"};
-    std::vector<defs::dacIndex> indices{defs::V_POWER_A, defs::V_POWER_B,
-                                        defs::V_POWER_C, defs::V_POWER_D};
-
     if (det.isVirtualDetectorServer().tsquash("Inconsistent virtual servers")) {
-        cmds.push_back("v_io");
-        indices.push_back(defs::V_POWER_IO);
-    }
+
+        std::vector<std::string> cmds{"v_a", "v_b", "v_c", "v_d", "v_io"};
+        std::vector<defs::dacIndex> indices{defs::V_POWER_A, defs::V_POWER_B,
+                                            defs::V_POWER_C, defs::V_POWER_D,
+                                            defs::V_POWER_IO};
 
         for (size_t i = 0; i < cmds.size(); ++i) {
             if (det_type == defs::CHIPTESTBOARD ||
@@ -1056,6 +1054,11 @@ TEST_CASE("v_abcd", "[.cmdcall]") {
                     REQUIRE(oss2.str() == cmds[i] + " 1200\n");
                 }
                 for (int i = 0; i != det.size(); ++i) {
+                    if (det_type == defs::XILINX_CHIPTESTBOARD &&
+                        prev_val[i] == -100) {
+                        prev_val[i] = 0;
+                        continue;
+                    }
                     det.setPower(indices[i], prev_val[i], {i});
                 }
 
@@ -1063,6 +1066,7 @@ TEST_CASE("v_abcd", "[.cmdcall]") {
                 REQUIRE_THROWS(caller.call(cmds[i], {}, -1, GET));
             }
         }
+    }
 }
 
 TEST_CASE("v_io", "[.cmdcall]") {
@@ -1330,4 +1334,366 @@ TEST_CASE("led", "[.cmdcall]") {
     }
 }
 
+TEST_CASE("define_reg", "[.cmdcall][.definecmds]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+
+    if (det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::XILINX_CHIPTESTBOARD) {
+
+        auto prev_reg_defines = det.getRegisterDefinitions();
+        auto prev_bit_defines = det.getBitDefinitions();
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+
+        {
+            // invalid puts
+            // missing arg
+            REQUIRE_THROWS(caller.call("define_reg", {}, -1, GET));
+            // missing arg
+            REQUIRE_THROWS(caller.call("define_reg", {"TEST_REG"}, -1, PUT));
+            // invalid module id
+            REQUIRE_THROWS(
+                caller.call("define_reg", {"TEST_REG", "0x201"}, 0, PUT));
+
+            // valid put
+            REQUIRE_NOTHROW(
+                caller.call("define_reg", {"TEST_REG", "0x200"}, -1, PUT));
+            // modify reg
+            REQUIRE_NOTHROW(
+                caller.call("define_reg", {"TEST_REG", "0x201"}, -1, PUT));
+            REQUIRE_NOTHROW(
+                caller.call("define_reg", {"TEST_REG2", "0x202"}, -1, PUT));
+
+            // invalid puts
+            // existing reg addr
+            REQUIRE_THROWS(
+                caller.call("define_reg", {"TEST_REG3", "0x201"}, -1, PUT));
+
+            // valid gets
+            {
+                // get by name
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("define_reg", {"TEST_REG"}, -1, GET, oss));
+                REQUIRE(oss.str() == "define_reg 0x201\n");
+            }
+            {
+                // get by addr
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("define_reg", {"0x201"}, -1, GET, oss));
+                REQUIRE(oss.str() == "define_reg TEST_REG\n");
+            }
+
+            // invalid gets
+            // doesnt exist
+            REQUIRE_THROWS(caller.call("define_reg", {"TEST_REG3"}, -1, GET));
+            REQUIRE_THROWS(caller.call("define_reg", {"0x203"}, -1, GET));
+            // ensure correct exception message
+            try {
+                caller.call("define_reg", {"0x203"}, -1, GET);
+            } catch (const std::exception &e) {
+                REQUIRE(std::string(e.what()).find(
+                            "No entry found for value") != std::string::npos);
+            }
+        }
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+
+        det.setRegisterDefinitions(prev_reg_defines);
+        det.setBitDefinitions(prev_bit_defines);
+
+    } else {
+        REQUIRE_THROWS(
+            caller.call("define_reg", {"TEST_REG", "0x200"}, -1, PUT));
+        REQUIRE_THROWS(caller.call("define_reg", {"TEST_REG"}, -1, GET));
+    }
+}
+
+TEST_CASE("define_bit", "[.cmdcall][.definecmds]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+
+    if (det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::XILINX_CHIPTESTBOARD) {
+
+        auto prev_reg_defines = det.getRegisterDefinitions();
+        auto prev_bit_defines = det.getBitDefinitions();
+
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+        det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
+        det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
+
+        {
+            // invalid puts
+            // skipped register
+            REQUIRE_THROWS(
+                caller.call("define_bit", {"TEST_BIT", "1"}, -1, PUT));
+            // named register doesnt exist
+            REQUIRE_THROWS(caller.call(
+                "define_bit", {"TEST_BIT", "RANDOM_REG", "1"}, -1, PUT));
+            // invalid bit position
+            REQUIRE_THROWS(
+                caller.call("define", {"TEST_BIT", "TEST_REG", "32"}, -1, PUT));
+
+            // valid puts
+            REQUIRE_NOTHROW(caller.call(
+                "define_bit", {"TEST_BIT", "TEST_REG2", "1"}, -1, PUT));
+            // modify reg
+            REQUIRE_NOTHROW(caller.call(
+                "define_bit", {"TEST_BIT", "TEST_REG", "1"}, -1, PUT));
+
+            // modify position
+            REQUIRE_NOTHROW(caller.call(
+                "define_bit", {"TEST_BIT", "TEST_REG", "2"}, -1, PUT));
+            // another bit to same reg
+            REQUIRE_NOTHROW(caller.call(
+                "define_bit", {"TEST_BIT2", "TEST_REG", "4"}, -1, PUT));
+            // bit to a different reg
+            REQUIRE_NOTHROW(caller.call(
+                "define_bit", {"TEST_BIT3", "TEST_REG2", "3"}, -1, PUT));
+
+            // valid gets
+            {
+                // get by name
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("define_bit", {"TEST_BIT"}, -1, GET, oss));
+                REQUIRE(oss.str() == "define_bit [TEST_REG, 2]\n");
+            }
+            {
+                // get by addr+pos name
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("define_bit", {"TEST_REG", "2"}, -1, GET, oss));
+                REQUIRE(oss.str() == "define_bit TEST_BIT\n");
+            }
+            {
+                // get by addr val + pos
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("define_bit", {"0x201", "2"}, -1, GET, oss));
+                REQUIRE(oss.str() == "define_bit TEST_BIT\n");
+            }
+
+            // invalid gets
+            // bit doesnt exist
+            REQUIRE_THROWS(
+                caller.call("define_bit", {"TEST_REG", "3"}, -1, GET));
+            // addr doesnt exist
+            REQUIRE_THROWS(
+                caller.call("define_bit", {"TEST_REG3", "2"}, -1, GET));
+            // ensure correct exception message
+            try {
+                caller.call("define_bit", {"TEST_REG", "3"}, -1, GET);
+            } catch (const std::exception &e) {
+                REQUIRE(std::string(e.what()).find(
+                            "No entry found for value") != std::string::npos);
+            }
+        }
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+
+        det.setRegisterDefinitions(prev_reg_defines);
+        det.setBitDefinitions(prev_bit_defines);
+
+    } else {
+        REQUIRE_THROWS(
+            caller.call("define_bit", {"TEST_BIT", "0x200", "2"}, -1, PUT));
+        REQUIRE_THROWS(caller.call("define_bit", {"0x200", "2"}, -1, GET));
+    }
+}
+
+TEST_CASE("using define for reg, setbit, getbit and clearbit",
+          "[.cmdcall][.definecmds]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+
+    if (det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::XILINX_CHIPTESTBOARD) {
+
+        if (det.isVirtualDetectorServer().tsquash(
+                "inconsistent virtual values")) {
+
+            auto prev_reg_defines = det.getRegisterDefinitions();
+            auto prev_bit_defines = det.getBitDefinitions();
+
+            det.clearRegisterDefinitions();
+            det.clearBitDefinitions();
+            det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
+            det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
+            det.setBitDefinition("TEST_BIT",
+                                 BitAddress(RegisterAddress(0x201), 2));
+            det.setBitDefinition("TEST_BIT2",
+                                 BitAddress(RegisterAddress(0x201), 4));
+            det.setBitDefinition("TEST_BIT3",
+                                 BitAddress(RegisterAddress(0x202), 3));
+
+            auto prev_val_addr = det.readRegister(RegisterAddress(0x201));
+            auto prev_val_addr2 = det.readRegister(RegisterAddress(0x202));
+
+            // invalid puts
+            // doesnt exist addr
+            REQUIRE_THROWS(
+                caller.call("reg", {"RANDOM_REG", "0xf00"}, -1, PUT));
+            REQUIRE_THROWS(
+                caller.call("clearbit", {"RANDOM_REG", "TEST_BIT"}, -1, PUT));
+            REQUIRE_THROWS(
+                caller.call("setbit", {"RANDOM_REG", "TEST_BIT"}, -1, PUT));
+            REQUIRE_THROWS(
+                caller.call("getbit", {"RANDOM_REG", "TEST_BIT"}, -1, GET));
+            // using bit name for reg (only hardcoded values allowed)
+            REQUIRE_THROWS(
+                caller.call("reg", {"TEST_REG", "TEST_BIT"}, -1, PUT));
+            // using bit name and reg (only bit names or both reg and bit
+            // hardcoded allowed)
+            REQUIRE_THROWS(
+                caller.call("clearbit", {"TEST_REG", "TEST_BIT"}, -1, PUT));
+            REQUIRE_THROWS(
+                caller.call("setbit", {"TEST_REG", "TEST_BIT"}, -1, PUT));
+            REQUIRE_THROWS(
+                caller.call("getbit", {"TEST_REG", "TEST_BIT"}, -1, GET));
+
+            // valid puts and gets
+            {
+                // reg hard coded value of 0
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("reg", {"TEST_REG", "0x0"}, -1, PUT));
+                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
+                REQUIRE(oss.str() == "reg 0x0\n");
+            }
+            {
+                // reg hard coded value
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(
+                    caller.call("reg", {"TEST_REG", "0x10"}, -1, PUT));
+                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
+                REQUIRE(oss.str() == "reg 0x10\n");
+            }
+            {
+                // set bit
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(caller.call("setbit", {"TEST_BIT"}, -1, PUT));
+                REQUIRE_NOTHROW(
+                    caller.call("setbit", {"TEST_REG", "2"}, -1, PUT));
+                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
+                REQUIRE(oss.str() == "reg 0x14\n");
+            }
+            {
+                // get bit
+                std::ostringstream oss, oss2;
+                REQUIRE_NOTHROW(
+                    caller.call("getbit", {"TEST_REG", "2"}, -1, GET, oss));
+                REQUIRE(oss.str() == "getbit 1\n");
+                REQUIRE_NOTHROW(
+                    caller.call("getbit", {"TEST_BIT"}, -1, GET, oss2));
+                REQUIRE(oss2.str() == "getbit 1\n");
+            }
+            {
+                // clear bit
+                std::ostringstream oss;
+                REQUIRE_NOTHROW(caller.call("clearbit", {"TEST_BIT"}, -1, PUT));
+                REQUIRE_NOTHROW(
+                    caller.call("clearbit", {"TEST_REG", "2"}, -1, PUT));
+                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
+                REQUIRE(oss.str() == "reg 0x10\n");
+            }
+            for (int i = 0; i != det.size(); ++i) {
+                det.writeRegister(RegisterAddress(0x201),
+                                  RegisterValue(prev_val_addr[i]), false, {i});
+                det.writeRegister(RegisterAddress(0x202),
+                                  RegisterValue(prev_val_addr2[i]), false, {i});
+            }
+            det.clearRegisterDefinitions();
+            det.clearBitDefinitions();
+
+            det.setRegisterDefinitions(prev_reg_defines);
+            det.setBitDefinitions(prev_bit_defines);
+        }
+
+    } else {
+        REQUIRE_THROWS(caller.call("reg", {"TEST_REG", "0x200"}, -1, PUT));
+        REQUIRE_THROWS(caller.call("reg", {"TEST_REG"}, -1, GET));
+    }
+}
+
+TEST_CASE("definelist_reg", "[.cmdcall][.definecmds]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+
+    if (det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::XILINX_CHIPTESTBOARD) {
+
+        auto prev_reg_defines = det.getRegisterDefinitions();
+
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+        det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
+        det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
+
+        // invalid
+        // cannot put
+        REQUIRE_THROWS(
+            caller.call("definelist_reg", {"TEST_REG", "0x201"}, -1, PUT));
+        // too many args
+        REQUIRE_THROWS(caller.call("definelist_reg", {"TEST_MACRO"}, -1, GET));
+
+        // valid
+        REQUIRE_NOTHROW(caller.call("definelist_reg", {}, -1, GET));
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+
+        det.setRegisterDefinitions(prev_reg_defines);
+    } else {
+        REQUIRE_THROWS(caller.call("definelist_reg", {}, -1, GET));
+    }
+}
+
+TEST_CASE("definelist_bit", "[.cmdcall][.definecmds]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+
+    if (det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::XILINX_CHIPTESTBOARD) {
+
+        auto prev_reg_defines = det.getRegisterDefinitions();
+        auto prev_bit_defines = det.getBitDefinitions();
+
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+        det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
+        det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
+        det.setBitDefinition("TEST_BIT", BitAddress(RegisterAddress(0x201), 2));
+        det.setBitDefinition("TEST_BIT2",
+                             BitAddress(RegisterAddress(0x201), 4));
+        det.setBitDefinition("TEST_BIT3",
+                             BitAddress(RegisterAddress(0x202), 3));
+
+        // invalid
+        // cannot put
+        REQUIRE_THROWS(
+            caller.call("definelist_bit", {"TEST_BIT", "0x201", "2"}, -1, PUT));
+        // too many args
+        REQUIRE_THROWS(caller.call("definelist_bit", {"TEST_BIT"}, -1, GET));
+
+        // valid
+        REQUIRE_NOTHROW(caller.call("definelist_bit", {}, -1, GET));
+        det.clearRegisterDefinitions();
+        det.clearBitDefinitions();
+
+        det.setRegisterDefinitions(prev_reg_defines);
+        det.setBitDefinitions(prev_bit_defines);
+    } else {
+        REQUIRE_THROWS(caller.call("definelist_bit", {}, -1, GET));
+    }
+}
+
 } // namespace sls

slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp

@@ -27,7 +27,7 @@ TEST_CASE("temp_fpgaext", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpgaext", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpgaext", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_fpgaext "));
+        std::string s = (oss.str()).erase(0, strlen("temp_fpgaext "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpgaext", {}, -1, GET));
@@ -42,7 +42,7 @@ TEST_CASE("temp_10ge", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_10ge", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_10ge", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_10ge "));
+        std::string s = (oss.str()).erase(0, strlen("temp_10ge "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_10ge", {}, -1, GET));
@@ -57,7 +57,7 @@ TEST_CASE("temp_dcdc", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_dcdc", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_dcdc", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_dcdc "));
+        std::string s = (oss.str()).erase(0, strlen("temp_dcdc "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_dcdc", {}, -1, GET));
@@ -72,7 +72,7 @@ TEST_CASE("temp_sodl", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_sodl", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_sodl", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_sodl "));
+        std::string s = (oss.str()).erase(0, strlen("temp_sodl "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_sodl", {}, -1, GET));
@@ -87,7 +87,7 @@ TEST_CASE("temp_sodr", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_sodr", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_sodr", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_sodr "));
+        std::string s = (oss.str()).erase(0, strlen("temp_sodr "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_sodr", {}, -1, GET));
@@ -102,7 +102,7 @@ TEST_CASE("temp_fpgafl", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpgafl", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpgafl", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_fpgafl "));
+        std::string s = (oss.str()).erase(0, strlen("temp_fpgafl "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpgafl", {}, -1, GET));
@@ -117,7 +117,7 @@ TEST_CASE("temp_fpgafr", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpgafr", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpgafr", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_fpgafr "));
+        std::string s = (oss.str()).erase(0, strlen("temp_fpgafr "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpgafr", {}, -1, GET));
@@ -421,7 +421,7 @@ TEST_CASE("measuredperiod", "[.cmdcall]") {
         } else {
             s = st.erase(0, strlen("measuredperiod "));
         }
-        double const val = std::stod(s);
+        double val = std::stod(s);
         // REQUIRE(val >= 1.0);
         REQUIRE(val < 2.0);
         for (int i = 0; i != det.size(); ++i) {
@@ -460,7 +460,7 @@ TEST_CASE("measuredsubperiod", "[.cmdcall]") {
         } else {
             s = st.erase(0, strlen("measuredsubperiod "));
         }
-        double const val = std::stod(s);
+        double val = std::stod(s);
         REQUIRE(val >= 0);
         REQUIRE(val < 1000);
         for (int i = 0; i != det.size(); ++i) {

slsDetectorSoftware/tests/Caller/test-Caller-global.cpp

@@ -22,9 +22,9 @@ void test_valid_port_caller(const std::string &command,
     if (arg.empty())
         arg.push_back("0");
 
-    int const test_values[3] = {77797, -1, 0};
+    int test_values[3] = {77797, -1, 0};
     for (int i = 0; i != 3; ++i) {
-        int const port_number = test_values[i];
+        int port_number = test_values[i];
         arg[arg.size() - 1] = std::to_string(port_number);
         REQUIRE_THROWS(caller.call(command, arg, detector_id, action));
         /*REQUIRE_THROWS_WITH(proxy.Call(command, arguments, detector_id,
@@ -72,7 +72,7 @@ void test_onchip_dac_caller(defs::dacIndex index, const std::string &dacname,
     REQUIRE_THROWS(
         caller.call(dacname, {"-1", "0x400"}, -1, PUT)); // max val is 0x3ff
 
-    int const chipIndex = -1; // for now, it is -1 only
+    int chipIndex = -1; // for now, it is -1 only
     auto prev_val = det.getOnChipDAC(index, chipIndex);
     auto dacValueStr = ToStringHex(dacvalue);
     auto chipIndexStr = std::to_string(chipIndex);
@@ -115,10 +115,10 @@ void test_acquire_binary_file_size(const testFileInfo &file_info,
                                    uint64_t num_frames_to_acquire,
                                    uint64_t expected_image_size) {
     assert(file_info.file_format == defs::BINARY);
-    std::string const fname = file_info.file_path + "/" + file_info.file_prefix +
+    std::string fname = file_info.file_path + "/" + file_info.file_prefix +
                         "_d0_f0_" + std::to_string(file_info.file_acq_index) +
                         ".raw";
-    uint64_t const expected_file_size =
+    uint64_t expected_file_size =
         num_frames_to_acquire *
         (expected_image_size + sizeof(defs::sls_receiver_header));
     auto actual_file_size = std::filesystem::file_size(fname);
@@ -136,7 +136,7 @@ void test_acquire_with_receiver(Caller &caller, const Detector &det) {
     REQUIRE_NOTHROW(caller.call("start", {}, -1, PUT));
     bool idle = false;
     while (!idle) {
-        std::ostringstream const oss;
+        std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("status", {}, -1, GET));
         auto statusList = det.getDetectorStatus();
         if (statusList.any(defs::ERROR)) {
@@ -154,7 +154,7 @@ void create_files_for_acquire(
     const std::optional<testCtbAcquireInfo> &test_info) {
 
     // save previous state
-    testFileInfo const prev_file_info = get_file_state(det);
+    testFileInfo prev_file_info = get_file_state(det);
     auto prev_num_frames = det.getNumberOfFrames().tsquash(
         "Inconsistent number of frames to acquire");
     std::optional<testCtbAcquireInfo> prev_ctb_config_info{};
@@ -163,7 +163,7 @@ void create_files_for_acquire(
     }
 
     // set state for acquire
-    testFileInfo const test_file_info;
+    testFileInfo test_file_info;
     set_file_state(det, test_file_info);
     det.setNumberOfFrames(num_frames);
     if (test_info) {
@@ -265,10 +265,10 @@ calculate_ctb_image_size(const testCtbAcquireInfo &test_info,
     inputs.dbitList = test_info.dbit_list;
 
     auto out = computeCtbImageSize(inputs);
-    uint64_t const image_size =
+    uint64_t image_size =
         out.nAnalogBytes + out.nDigitalBytes + out.nTransceiverBytes;
     LOG(logDEBUG1) << "Expected image size: " << image_size;
-    int const npixelx = out.nPixelsX;
+    int npixelx = out.nPixelsX;
     LOG(logDEBUG1) << "Expected number of pixels in x: " << npixelx;
     return std::make_pair(image_size, npixelx);
 }

slsDetectorSoftware/tests/Caller/test-Caller-jungfrau.cpp

@@ -580,9 +580,9 @@ TEST_CASE("pedestalmode", "[.cmdcall]") {
             REQUIRE(oss.str() == "pedestalmode [disabled]\n");
         }
 
-        uint8_t const pedestalFrames = 50;
-        uint16_t const pedestalLoops = 100;
-        int64_t const expNumFrames = pedestalFrames * pedestalLoops * 2;
+        uint8_t pedestalFrames = 50;
+        uint16_t pedestalLoops = 100;
+        int64_t expNumFrames = pedestalFrames * pedestalLoops * 2;
         auto origFrames = det.getNumberOfFrames().squash(-1);
         auto origTriggers = det.getNumberOfTriggers().squash(-1);
 

slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp

@@ -183,7 +183,7 @@ void read_from_json(const Document &doc, const std::string &name,
     }
     int index = 0;
     for (const auto &item : json_values) {
-        std::string const sval = item.GetString();
+        std::string sval = item.GetString();
         retval[index++] = StringTo<sls::ns>(sval);
     }
 }
@@ -330,7 +330,7 @@ void test_master_file_version(const Detector &det,
     // different values for json and hdf5
     // hdf5 version in atttribute and not dataset
     double retval{};
-    std::string const name = MasterAttributes::N_VERSION.data();
+    std::string name = MasterAttributes::N_VERSION.data();
     if (doc.has_value()) {
         const auto &d = *doc;
         REQUIRE(d.HasMember(MasterAttributes::N_VERSION.data()));
@@ -381,14 +381,14 @@ void test_master_file_image_size(const Detector &det,
 
     auto det_type =
         det.getDetectorType().tsquash("Inconsistent detector types to test");
-    int const bytes_per_pixel = det.getDynamicRange().squash() / 8;
-    detParameters const par(det_type);
+    int bytes_per_pixel = det.getDynamicRange().squash() / 8;
+    detParameters par(det_type);
 
     int image_size = 0;
     switch (det_type) {
 
     case defs::EIGER: {
-        int const num_chips = (par.nChipX / 2);
+        int num_chips = (par.nChipX / 2);
         image_size = par.nChanX * par.nChanY * num_chips * bytes_per_pixel;
     } break;
 
@@ -402,9 +402,9 @@ void test_master_file_image_size(const Detector &det,
     } break;
 
     case defs::MYTHEN3: {
-        int const counter_mask = det.getCounterMask().squash();
-        int const num_counters = __builtin_popcount(counter_mask);
-        int const num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS;
+        int counter_mask = det.getCounterMask().squash();
+        int num_counters = __builtin_popcount(counter_mask);
+        int num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS;
         image_size = num_channels_per_counter * num_counters * par.nChipX *
                      bytes_per_pixel;
     } break;
@@ -415,7 +415,7 @@ void test_master_file_image_size(const Detector &det,
 
     case defs::CHIPTESTBOARD:
     case defs::XILINX_CHIPTESTBOARD: {
-        testCtbAcquireInfo const test_info{};
+        testCtbAcquireInfo test_info{};
         image_size = calculate_ctb_image_size(
                          test_info, (det_type == defs::XILINX_CHIPTESTBOARD))
                          .first;
@@ -439,14 +439,14 @@ void test_master_file_det_size(const Detector &det,
     // m3 assumes all counters enabled when getting num channels from client
     // TODO: in future, remove assumption
     if (det_type == defs::MYTHEN3) {
-        int const nchan = portSize.x / MAX_NUM_COUNTERS;
+        int nchan = portSize.x / MAX_NUM_COUNTERS;
         auto counter_mask = det.getCounterMask().tsquash(
             "Inconsistent counter mask for Mythen3 detector");
-        int const num_counters = __builtin_popcount(counter_mask);
+        int num_counters = __builtin_popcount(counter_mask);
         portSize.x = nchan * num_counters;
     } else if (det_type == defs::CHIPTESTBOARD ||
                det_type == defs::XILINX_CHIPTESTBOARD) {
-        testCtbAcquireInfo const test_info{};
+        testCtbAcquireInfo test_info{};
         portSize.x = calculate_ctb_image_size(
                          test_info, det_type == defs::XILINX_CHIPTESTBOARD)
                          .second;
@@ -534,7 +534,7 @@ void test_master_file_total_frames(const Detector &det,
             det.getNumberOfAdditionalStorageCells().tsquash(
                 "Inconsistent number of additional storage cells");
     }
-    uint64_t const total_frames =
+    uint64_t total_frames =
         numFrames * repeats * (int64_t)(numAdditionalStorageCells + 1);
 
     REQUIRE_NOTHROW(check_master_file<uint64_t>(
@@ -549,14 +549,14 @@ void test_master_file_rois(const Detector &det,
         det.getDetectorType().tsquash("Inconsistent detector types to test");
     // compensate for m3 channel size and counter mask mess
     if (det_type == defs::MYTHEN3) {
-        int const nchan = detsize.x / MAX_NUM_COUNTERS;
+        int nchan = detsize.x / MAX_NUM_COUNTERS;
         auto counter_mask = det.getCounterMask().tsquash(
             "Inconsistent counter mask for Mythen3 detector");
-        int const num_counters = __builtin_popcount(counter_mask);
+        int num_counters = __builtin_popcount(counter_mask);
         detsize.x = nchan * num_counters;
     }
     // replace -1 for complete ROI
-    bool const is2D = (detsize.y > 1);
+    bool is2D = (detsize.y > 1);
     for (auto &roi : rois) {
         if (roi.completeRoi()) {
             roi.xmin = 0;
@@ -751,7 +751,7 @@ void test_master_file_burst_mode(const Detector &det,
 
 void test_master_file_adc_mask(const Detector &det,
                                const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_ctb_config{};
+    testCtbAcquireInfo test_ctb_config{};
     auto adc_mask = test_ctb_config.adc_enable_10g;
     auto det_type = det.getDetectorType().squash();
     if (det_type == defs::CHIPTESTBOARD) {
@@ -766,7 +766,7 @@ void test_master_file_adc_mask(const Detector &det,
 
 void test_master_file_analog_flag(const Detector &det,
                                   const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto romode = test_info.readout_mode;
     auto analog = static_cast<int>(
         (romode == defs::ANALOG_ONLY || romode == defs::ANALOG_AND_DIGITAL));
@@ -777,7 +777,7 @@ void test_master_file_analog_flag(const Detector &det,
 
 void test_master_file_analog_samples(const Detector &det,
                                      const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto analog_samples = test_info.num_adc_samples;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -786,7 +786,7 @@ void test_master_file_analog_samples(const Detector &det,
 
 void test_master_file_digital_flag(const Detector &det,
                                    const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto romode = test_info.readout_mode;
     auto digital = static_cast<int>(romode == defs::DIGITAL_ONLY ||
                                     romode == defs::ANALOG_AND_DIGITAL ||
@@ -798,7 +798,7 @@ void test_master_file_digital_flag(const Detector &det,
 
 void test_master_file_digital_samples(const Detector &det,
                                       const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto digital_samples = test_info.num_dbit_samples;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -807,7 +807,7 @@ void test_master_file_digital_samples(const Detector &det,
 
 void test_master_file_dbit_offset(const Detector &det,
                                   const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto dbit_offset = test_info.dbit_offset;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -816,7 +816,7 @@ void test_master_file_dbit_offset(const Detector &det,
 
 void test_master_file_dbit_reorder(const Detector &det,
                                    const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto dbit_reorder = test_info.dbit_reorder;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -825,7 +825,7 @@ void test_master_file_dbit_reorder(const Detector &det,
 
 void test_master_file_dbit_bitset(const Detector &det,
                                   const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     uint64_t dbit_bitset = 0;
     for (auto &i : test_info.dbit_list) {
         dbit_bitset |= (static_cast<uint64_t>(1) << i);
@@ -837,7 +837,7 @@ void test_master_file_dbit_bitset(const Detector &det,
 
 void test_master_file_transceiver_mask(const Detector &det,
                                        const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto trans_mask = test_info.transceiver_mask;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -846,7 +846,7 @@ void test_master_file_transceiver_mask(const Detector &det,
 
 void test_master_file_transceiver_flag(const Detector &det,
                                        const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto romode = test_info.readout_mode;
     auto trans = static_cast<int>(romode == defs::DIGITAL_AND_TRANSCEIVER ||
                                   romode == defs::TRANSCEIVER_ONLY);
@@ -857,7 +857,7 @@ void test_master_file_transceiver_flag(const Detector &det,
 
 void test_master_file_transceiver_samples(const Detector &det,
                                           const std::optional<Document> &doc) {
-    testCtbAcquireInfo const test_info{};
+    testCtbAcquireInfo test_info{};
     auto trans_samples = test_info.num_trans_samples;
     REQUIRE_NOTHROW(check_master_file<int>(
         doc, MasterAttributes::N_TRANSCEIVER_SAMPLES.data(), trans_samples));
@@ -1005,17 +1005,17 @@ Document parse_binary_master_attributes(std::string file_path) {
     REQUIRE(file.is_open());
     std::stringstream buffer;
     buffer << file.rdbuf();
-    std::string const json_str = buffer.str();
+    std::string json_str = buffer.str();
 
     Document doc;
-    ParseResult const result = doc.Parse(json_str.c_str());
+    ParseResult result = doc.Parse(json_str.c_str());
     if (result == 0) {
         std::cout << "JSON parse error: " << GetParseError_En(result.Code())
                   << " (at offset " << result.Offset() << ")" << std::endl;
 
         // Optional: Show problematic snippet
-        size_t const offset = result.Offset();
-        std::string const context =
+        size_t offset = result.Offset();
+        std::string context =
             json_str.substr(std::max(0, (int)offset - 20), 40);
         std::cout << "Context around error: \"" << context << "\"" << std::endl;
     }
@@ -1039,7 +1039,7 @@ TEST_CASE("check_master_file_attributes", "[.cmdcall][.cmdacquire][.cmdattr]") {
     auto det_type =
         det.getDetectorType().tsquash("Inconsistent detector types to test");
 
-    int64_t const num_frames = 1;
+    int64_t num_frames = 1;
     switch (det_type) {
     case defs::EIGER:
     case defs::JUNGFRAU:
@@ -1057,11 +1057,11 @@ TEST_CASE("check_master_file_attributes", "[.cmdcall][.cmdacquire][.cmdattr]") {
         throw sls::RuntimeError("Unsupported detector type for this test");
     }
 
-    testFileInfo const file_info;
-    std::string const master_file_prefix = file_info.getMasterFileNamePrefix();
+    testFileInfo file_info;
+    std::string master_file_prefix = file_info.getMasterFileNamePrefix();
 
     // binary
-    std::string const fname =
+    std::string fname =
         master_file_prefix + ".json"; // /tmp/sls_test_master_0.json
     auto doc = std::make_optional(parse_binary_master_attributes(fname));
     test_master_file_metadata(det, doc);

slsDetectorSoftware/tests/Caller/test-Caller-mythen3.cpp

@@ -509,11 +509,11 @@ TEST_CASE("interpolation", "[.cmdcall]") {
         auto prev_mask = det.getCounterMask();
         auto prev_vth3DacVal = det.getDAC(defs::VTH3, 0, {});
 
-        int const disabledDacValue = 2800;
+        int disabledDacValue = 2800;
         auto fixedVth3DacVal = 1000;
         det.setDAC(defs::VTH3, fixedVth3DacVal, 0, {});
         // mask with counter 3 disabled and enabled(to test vth3)
-        uint32_t const fixedMask[2] = {0x2, 0x4};
+        uint32_t fixedMask[2] = {0x2, 0x4};
         for (int i = 0; i != 2; ++i) {
             det.setCounterMask(fixedMask[i]);
             {
@@ -532,7 +532,7 @@ TEST_CASE("interpolation", "[.cmdcall]") {
                 REQUIRE(oss.str() == "interpolation 0\n");
                 REQUIRE(det.getCounterMask().tsquash(
                             "inconsistent counter mask") == fixedMask[i]);
-                int const expectedVth3DacVal =
+                int expectedVth3DacVal =
                     (fixedMask[i] & 0x4 ? fixedVth3DacVal : disabledDacValue);
                 REQUIRE(det.getDAC(defs::VTH3, 0, {0})
                             .tsquash("inconsistent vth3 dac value") ==
@@ -566,13 +566,13 @@ TEST_CASE("pumpprobe", "[.cmdcall]") {
         auto prev_vth2DacVal = det.getDAC(defs::VTH2, 0, {});
         auto prev_vth3DacVal = det.getDAC(defs::VTH3, 0, {});
 
-        int const disabledDacValue = 2800;
+        int disabledDacValue = 2800;
         auto fixedVthDacVal = 1000;
         det.setDAC(defs::VTH1, fixedVthDacVal, 0, {});
         det.setDAC(defs::VTH2, fixedVthDacVal, 0, {});
         det.setDAC(defs::VTH3, fixedVthDacVal, 0, {});
         // mask with counter 2 disabled and enabled(to test vth2)
-        uint32_t const fixedMask[2] = {0x4, 0x3};
+        uint32_t fixedMask[2] = {0x4, 0x3};
         for (int i = 0; i != 2; ++i) {
             std::cout << "i:" << i << std::endl;
             det.setCounterMask(fixedMask[i]);

slsDetectorSoftware/tests/Caller/test-Caller-pattern.cpp

@@ -114,8 +114,8 @@ TEST_CASE("patword", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
-        int const addr = 0x23;
-        std::string const saddr = ToStringHex(addr, 4);
+        int addr = 0x23;
+        std::string saddr = ToStringHex(addr, 4);
         auto prev_val = det.getPatternWord(addr);
         {
             std::ostringstream oss;
@@ -189,9 +189,9 @@ TEST_CASE("patloop", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternLoopAddresses(iLoop);
-            std::string const sLoop = ToString(iLoop);
+            std::string sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string const deprecatedCmd = "patloop" + sLoop;
+                std::string deprecatedCmd = "patloop" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"0x20", "0x5c"}, -1, PUT, oss);
@@ -238,9 +238,9 @@ TEST_CASE("patnloop", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternLoopCycles(iLoop);
-            std::string const sLoop = ToString(iLoop);
+            std::string sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string const deprecatedCmd = "patnloop" + sLoop;
+                std::string deprecatedCmd = "patnloop" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"5"}, -1, PUT, oss);
@@ -284,9 +284,9 @@ TEST_CASE("patwait", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternWaitAddr(iLoop);
-            std::string const sLoop = ToString(iLoop);
+            std::string sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string const deprecatedCmd = "patwait" + sLoop;
+                std::string deprecatedCmd = "patwait" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"0x5c"}, -1, PUT, oss);
@@ -330,9 +330,9 @@ TEST_CASE("patwaittime", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternWaitClocks(iLoop);
-            std::string const sLoop = ToString(iLoop);
+            std::string sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string const deprecatedCmd = "patwaittime" + sLoop;
+                std::string deprecatedCmd = "patwaittime" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"8589936640"}, -1, PUT, oss);

slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp

@@ -30,7 +30,7 @@ TEST_CASE("rx_version", "[.cmdcall][.rx]") {
     Caller caller(&det);
     std::ostringstream oss;
     caller.call("rx_version", {}, -1, GET, oss);
-    sls::Version const v(APIRECEIVER);
+    sls::Version v(APIRECEIVER);
     std::ostringstream vs;
     vs << "rx_version " << v.concise() << '\n';
     REQUIRE(oss.str() == vs.str());
@@ -365,9 +365,9 @@ TEST_CASE("rx_padding", "[.cmdcall][.rx]") {
 TEST_CASE("rx_udpsocksize", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
-    int64_t const prev_val = det.getRxUDPSocketBufferSize().tsquash(
+    int64_t prev_val = det.getRxUDPSocketBufferSize().tsquash(
         "Need same udp socket buffer size to test");
-    std::string const s_new_val = std::to_string(prev_val);
+    std::string s_new_val = std::to_string(prev_val);
     /*std::string s_new_val = std::to_string(prev_val - 1000);
     { Need permissions
         std::ostringstream oss;
@@ -389,14 +389,14 @@ TEST_CASE("rx_realudpsocksize", "[.cmdcall][.rx]") {
     {
         std::ostringstream oss;
         caller.call("rx_udpsocksize", {}, -1, GET, oss);
-        std::string const s = (oss.str()).erase(0, strlen("rx_udpsocksize "));
+        std::string s = (oss.str()).erase(0, strlen("rx_udpsocksize "));
         val = std::stol(s);
     }
     {
         std::ostringstream oss;
         caller.call("rx_realudpsocksize", {}, -1, GET, oss);
-        std::string const s = (oss.str()).erase(0, strlen("rx_realudpsocksize "));
-        uint64_t const rval = std::stol(s);
+        std::string s = (oss.str()).erase(0, strlen("rx_realudpsocksize "));
+        uint64_t rval = std::stol(s);
         REQUIRE(rval >= val * 2);
     }
 }
@@ -476,10 +476,10 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
         REQUIRE_THROWS(caller.call("rx_roi", {"5", "10"}, -1, PUT));
     } else {
         auto prev_val = det.getRxROI();
-        defs::xy const detsize = det.getDetectorSize();
+        defs::xy detsize = det.getDetectorSize();
         auto portSize = det.getPortSize()[0];
-        int const delta = 50;
-        int const numinterfaces = det.getNumberofUDPInterfaces().tsquash(
+        int delta = 50;
+        int numinterfaces = det.getNumberofUDPInterfaces().tsquash(
             "inconsistent number of interfaces");
 
         // 1d
@@ -757,11 +757,11 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
         // TODO: check roi in master file
         {
             REQUIRE_NOTHROW(create_files_for_acquire(det, caller));
-            testFileInfo const file_info;
-            std::string const master_file_prefix =
+            testFileInfo file_info;
+            std::string master_file_prefix =
                 file_info.getMasterFileNamePrefix();
 
-            std::string const fname = master_file_prefix + ".json";
+            std::string fname = master_file_prefix + ".json";
             REQUIRE(std::filesystem::exists(fname) == true);
 #ifdef HDF5C
             fname = master_file_prefix + ".h5";

slsDetectorSoftware/tests/Caller/test-Caller.cpp

@@ -24,7 +24,7 @@ TEST_CASE("Calling help doesn't throw or cause segfault") {
     // Dont add [.cmdcall] tag this should run with normal tests
     Caller caller(nullptr);
     std::ostringstream os;
-    for (std::string const& cmd : caller.getAllCommands())
+    for (std::string cmd : caller.getAllCommands())
         REQUIRE_NOTHROW(
             caller.call(cmd, {}, -1, slsDetectorDefs::HELP_ACTION, os));
 }
@@ -291,7 +291,7 @@ TEST_CASE("threshold", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string const senergy = std::to_string(prev_energies[0]);
+            std::string senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("threshold", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() == "threshold [" + senergy + ", standard]\n");
@@ -319,15 +319,15 @@ TEST_CASE("threshold", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string const senergy = std::to_string(prev_energies[0]);
+            std::string senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("threshold", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() == "threshold [" + senergy + ", standard]\n");
             caller.call("threshold", {}, -1, GET, oss2);
             REQUIRE(oss2.str() == "threshold [" + senergy + ", " + senergy +
                                       ", " + senergy + "]\n");
-            std::string const senergy2 = std::to_string(prev_energies[1]);
-            std::string const senergy3 = std::to_string(prev_energies[2]);
+            std::string senergy2 = std::to_string(prev_energies[1]);
+            std::string senergy3 = std::to_string(prev_energies[2]);
             std::ostringstream oss3, oss4;
             caller.call("threshold", {senergy, senergy2, senergy3, "standard"},
                         -1, PUT, oss3);
@@ -370,7 +370,7 @@ TEST_CASE("thresholdnotb", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string const senergy = std::to_string(prev_energies[0]);
+            std::string senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("thresholdnotb", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() ==
@@ -398,7 +398,7 @@ TEST_CASE("thresholdnotb", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string const senergy = std::to_string(prev_energies[0]);
+            std::string senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("thresholdnotb", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() ==
@@ -406,8 +406,8 @@ TEST_CASE("thresholdnotb", "[.cmdcall]") {
             caller.call("threshold", {}, -1, GET, oss2);
             REQUIRE(oss2.str() == "threshold [" + senergy + ", " + senergy +
                                       ", " + senergy + "]\n");
-            std::string const senergy2 = std::to_string(prev_energies[1]);
-            std::string const senergy3 = std::to_string(prev_energies[2]);
+            std::string senergy2 = std::to_string(prev_energies[1]);
+            std::string senergy3 = std::to_string(prev_energies[2]);
             std::ostringstream oss3, oss4;
             caller.call("thresholdnotb",
                         {senergy, senergy2, senergy3, "standard"}, -1, PUT,
@@ -528,8 +528,8 @@ TEST_CASE("gappixels", "[.cmdcall]") {
     if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH)
         gapPixelTest = true;
     else if (det_type == defs::EIGER) {
-        bool const quad = det.getQuad().squash(false);
-        bool const fullModule = (det.getModuleGeometry().y % 2 == 0);
+        bool quad = det.getQuad().squash(false);
+        bool fullModule = (det.getModuleGeometry().y % 2 == 0);
         if (quad || fullModule) {
             gapPixelTest = true;
         }
@@ -658,9 +658,9 @@ TEST_CASE("badchannels", "[.cmdcall]") {
 
         REQUIRE_THROWS(caller.call("badchannels", {}, -1, GET));
 
-        std::string const fname_put =
+        std::string fname_put =
             getAbsolutePathFromCurrentProcess(TEST_FILE_NAME_BAD_CHANNELS);
-        std::string const fname_get = "/tmp/sls_test_channels.txt";
+        std::string fname_get = "/tmp/sls_test_channels.txt";
 
         REQUIRE_NOTHROW(caller.call("badchannels", {fname_put}, 0, PUT));
         REQUIRE_NOTHROW(caller.call("badchannels", {fname_get}, 0, GET));
@@ -976,7 +976,7 @@ TEST_CASE("dr", "[.cmdcall]") {
     auto det_type = det.getDetectorType().squash();
     if (det_type == defs::EIGER) {
         auto dr = det.getDynamicRange().squash();
-        std::array<int, 4> const vals{4, 8, 16, 32};
+        std::array<int, 4> vals{4, 8, 16, 32};
         for (const auto val : vals) {
             std::ostringstream oss1, oss2;
             caller.call("dr", {std::to_string(val)}, -1, PUT, oss1);
@@ -988,7 +988,7 @@ TEST_CASE("dr", "[.cmdcall]") {
     } else if (det_type == defs::MYTHEN3) {
         auto dr = det.getDynamicRange().squash();
         // not updated in firmware to support dr 1
-        std::array<int, 3> const vals{8, 16, 32};
+        std::array<int, 3> vals{8, 16, 32};
         for (const auto val : vals) {
             std::ostringstream oss1, oss2;
             caller.call("dr", {std::to_string(val)}, -1, PUT, oss1);
@@ -1542,7 +1542,7 @@ TEST_CASE("powerchip", "[.cmdcall]") {
                 "Inconsistent virtual detector "
                 "server to test powerchip command")) {
             det.setPowerChip(1);
-            int const hv = det.getHighVoltage().tsquash(
+            int hv = det.getHighVoltage().tsquash(
                 "Inconsistent high voltage to test "
                 "powerchip command");
 
@@ -1976,7 +1976,7 @@ TEST_CASE("temp_adc", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_adc", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_adc", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_adc "));
+        std::string s = (oss.str()).erase(0, strlen("temp_adc "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_adc", {}, -1, GET));
@@ -1991,7 +1991,7 @@ TEST_CASE("temp_fpga", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpga", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpga", {}, 0, GET, oss));
-        std::string const s = (oss.str()).erase(0, strlen("temp_fpga "));
+        std::string s = (oss.str()).erase(0, strlen("temp_fpga "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpga", {}, -1, GET));
@@ -2075,7 +2075,7 @@ TEST_CASE("defaultdac", "[.cmdcall]") {
             }
         }
         if (det_type == defs::JUNGFRAU) {
-            std::vector<defs::dacIndex> const daclist = {
+            std::vector<defs::dacIndex> daclist = {
                 defs::VREF_PRECH, defs::VREF_DS, defs::VREF_COMP};
             for (auto it : daclist) {
                 auto dacname = ToString(it);
@@ -2955,7 +2955,7 @@ TEST_CASE("txdelay_frame", "[.cmdcall]") {
             det_type == defs::MYTHEN3) {
             val = 5;
         }
-        std::string const sval = std::to_string(val);
+        std::string sval = std::to_string(val);
         {
             std::ostringstream oss1, oss2;
             caller.call("txdelay_frame", {sval}, -1, PUT, oss1);
@@ -2983,8 +2983,8 @@ TEST_CASE("txdelay", "[.cmdcall]") {
              det_type == defs::MYTHEN3) &&
             (det.size() < 2)) {
             REQUIRE_THROWS(caller.call("txdelay", {}, -1, GET));
-            int const val = 5;
-            std::string const sval = std::to_string(val);
+            int val = 5;
+            std::string sval = std::to_string(val);
             {
                 std::ostringstream oss1;
                 caller.call("txdelay", {sval}, -1, PUT, oss1);
@@ -3006,7 +3006,7 @@ TEST_CASE("txdelay", "[.cmdcall]") {
                 det_type == defs::MYTHEN3) {
                 val = 5;
             }
-            std::string const sval = std::to_string(val);
+            std::string sval = std::to_string(val);
             {
                 std::ostringstream oss1, oss2;
                 caller.call("txdelay", {sval}, -1, PUT, oss1);
@@ -3267,7 +3267,7 @@ TEST_CASE("update", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("reg", "[.cmdcall]") {
+TEST_CASE("reg", "[.cmdcall][.definecmds]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3279,19 +3279,19 @@ TEST_CASE("reg", "[.cmdcall]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string const saddr = ToStringHex(addr);
+        std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2;
             caller.call("reg", {saddr, "0x6", "--validate"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "reg [" + saddr + ", 0x6]\n");
+            REQUIRE(oss1.str() == "reg " + saddr + " 0x6\n");
             caller.call("reg", {saddr}, -1, GET, oss2);
             REQUIRE(oss2.str() == "reg 0x6\n");
         }
         {
             std::ostringstream oss1, oss2;
             caller.call("reg", {saddr, "0x5"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "reg [" + saddr + ", 0x5]\n");
+            REQUIRE(oss1.str() == "reg " + saddr + " 0x5\n");
             caller.call("reg", {saddr}, -1, GET, oss2);
             REQUIRE(oss2.str() == "reg 0x5\n");
         }
@@ -3326,7 +3326,7 @@ TEST_CASE("adcreg", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("setbit", "[.cmdcall]") {
+TEST_CASE("setbit", "[.cmdcall][.definecmds]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3338,7 +3338,7 @@ TEST_CASE("setbit", "[.cmdcall]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string const saddr = ToStringHex(addr);
+        std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2, oss3;
@@ -3356,7 +3356,7 @@ TEST_CASE("setbit", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("clearbit", "[.cmdcall]") {
+TEST_CASE("clearbit", "[.cmdcall][.definecmds]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3368,7 +3368,7 @@ TEST_CASE("clearbit", "[.cmdcall]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string const saddr = ToStringHex(addr);
+        std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2, oss3;
@@ -3386,7 +3386,7 @@ TEST_CASE("clearbit", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("getbit", "[.cmdcall]") {
+TEST_CASE("getbit", "[.cmdcall][.definecmds]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3398,7 +3398,7 @@ TEST_CASE("getbit", "[.cmdcall]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string const saddr = ToStringHex(addr);
+        std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2;

slsDetectorSoftware/tests/test-CmdParser.cpp

@@ -15,7 +15,7 @@ using vs = std::vector<std::string>;
 
 SCENARIO("Construction", "[support]") {
     GIVEN("A default constructed CmdParser") {
-        CmdParser const p;
+        CmdParser p;
         THEN("The state of the object is valid") {
             REQUIRE(p.detector_id() == -1);
             REQUIRE(p.multi_id() == 0);
@@ -31,7 +31,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
     GIVEN("A CmdParser") {
         CmdParser p;
         WHEN("Parsing an empty string") {
-            std::string const s;
+            std::string s;
             p.Parse(s);
             THEN("command and arguments are empty") {
                 REQUIRE(p.detector_id() == -1);
@@ -42,7 +42,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
             }
         }
         WHEN("Parsing a string with a single command") {
-            std::string const s = "vrf";
+            std::string s = "vrf";
             p.Parse(s);
             THEN("command is assigned and id's remain default") {
                 REQUIRE(p.command() == "vrf");
@@ -53,7 +53,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
             }
         }
         WHEN("Parsing a string with command and value") {
-            std::string const s = "vthreshold 1500";
+            std::string s = "vthreshold 1500";
             p.Parse(s);
             THEN("cmd and value are assigned and id's remain default") {
                 REQUIRE(p.command() == "vthreshold");
@@ -98,7 +98,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
         }
 
         WHEN("Parsing string with cmd and multiple arguments") {
-            std::string const s = "trimen 5000 6000 7000";
+            std::string s = "trimen 5000 6000 7000";
             p.Parse(s);
             THEN("cmd and args are correct") {
                 REQUIRE(p.command() == "trimen");
@@ -115,7 +115,7 @@ SCENARIO("Parsing strings with -h or --help", "[support]") {
     GIVEN("A parser") {
         CmdParser p;
         WHEN("Parsing a string with a command and help ") {
-            std::string const s = "-h list";
+            std::string s = "-h list";
 
             THEN("the command is correct and isHelp is set") {
                 p.Parse(s);
@@ -128,7 +128,7 @@ SCENARIO("Parsing strings with -h or --help", "[support]") {
             }
         }
         WHEN("Parsing a string with -h at a different position") {
-            std::string const s = "list -h something";
+            std::string s = "list -h something";
             THEN("its also done right") {
                 p.Parse(s);
                 REQUIRE(p.isHelp());
@@ -138,7 +138,7 @@ SCENARIO("Parsing strings with -h or --help", "[support]") {
             }
         }
         WHEN("Parsing a string with -help at a different position") {
-            std::string const s = "list --help something";
+            std::string s = "list --help something";
             THEN("its also done right") {
                 p.Parse(s);
                 REQUIRE(p.isHelp());
@@ -186,7 +186,7 @@ TEST_CASE("Parse with no arguments results in no command and default id",
           "[support]") {
     // build up argc and argv
     // first argument is the command used to call the binary
-    int const argc = 1;
+    int argc = 1;
     const char *const argv[]{"call"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -200,7 +200,7 @@ TEST_CASE("Parse with no arguments results in no command and default id",
 TEST_CASE(
     "Parse a command without client id and detector id results in default",
     "[support]") {
-    int const argc = 2;
+    int argc = 2;
     const char *const argv[]{"caller", "vrf"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -213,7 +213,7 @@ TEST_CASE(
 
 TEST_CASE("Parse a command with value but without client or detector id",
           "[support]") {
-    int const argc = 3;
+    int argc = 3;
     const char *const argv[]{"caller", "vrf", "3000"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -226,7 +226,7 @@ TEST_CASE("Parse a command with value but without client or detector id",
 }
 
 TEST_CASE("Decodes position") {
-    int const argc = 2;
+    int argc = 2;
     const char *const argv[]{"caller", "7:vrf"};
 
     CmdParser p;
@@ -239,7 +239,7 @@ TEST_CASE("Decodes position") {
 }
 
 TEST_CASE("Decodes double digit position", "[support]") {
-    int const argc = 2;
+    int argc = 2;
     const char *const argv[]{"caller", "73:vcmp"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -251,7 +251,7 @@ TEST_CASE("Decodes double digit position", "[support]") {
 }
 
 TEST_CASE("Decodes position and id", "[support]") {
-    int const argc = 2;
+    int argc = 2;
     const char *const argv[]{"caller", "5-8:vrf"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -263,7 +263,7 @@ TEST_CASE("Decodes position and id", "[support]") {
 }
 
 TEST_CASE("Double digit id", "[support]") {
-    int const argc = 2;
+    int argc = 2;
     const char *const argv[]{"caller", "56-8:vrf"};
     CmdParser p;
     p.Parse(argc, argv);

slsDetectorSoftware/tests/test-CtbConfig.cpp

@@ -6,15 +6,18 @@
 #include "CtbConfig.h"
 #include "SharedMemory.h"
 #include <fstream>
+#include <set>
 
 namespace sls {
 
 TEST_CASE("Default construction") {
-    static_assert(sizeof(CtbConfig) ==
-                      (2 * sizeof(int) + (18 + 32 + 64 + 5 + 8) * 20),
-                  "Size of CtbConfig does not match ");
+    /*TODO static_assert(sizeof(CtbConfig) ==
+                      (2 * sizeof(int) + (18 + 32 + 64 + 5 + 8) * 32) +
+                        (sizeof(size_t) * 2) + ((sizeof(uint32_t) + 32) * 64) +
+       ((32 + sizeof(uint32_t) + sizeof(int)) * 64), "Size of CtbConfig does not
+       match "); //8952 (8696)*/
 
-    CtbConfig const c;
+    CtbConfig c;
     auto dacnames = c.getDacNames();
     REQUIRE(dacnames.size() == 18);
     REQUIRE(dacnames[0] == "DAC0");
@@ -46,6 +49,16 @@ TEST_CASE("Default construction") {
     REQUIRE(sensenames[1] == "SLOWADC1");
     REQUIRE(sensenames[2] == "SLOWADC2");
     REQUIRE(sensenames[3] == "SLOWADC3");
+    auto regisernames = c.getRegisterNames();
+    REQUIRE(regisernames.size() == 0);
+    auto bitnames = c.getBitNames();
+    REQUIRE(bitnames.size() == 0);
+    REQUIRE(c.getRegisterNamesCount() == 0);
+    auto registerNames = c.getRegisterNames();
+    REQUIRE(registerNames.size() == 0);
+    REQUIRE(c.getBitNamesCount() == 0);
+    auto bitNames = c.getBitNames();
+    REQUIRE(bitNames.size() == 0);
 }
 
 TEST_CASE("Set and get a single dac name") {
@@ -81,8 +94,168 @@ TEST_CASE("Copy a CTB config") {
 TEST_CASE("Move CtbConfig ") {
     CtbConfig c1;
     c1.setDacName(3, "yetanothername");
-    CtbConfig const c2(std::move(c1));
+    CtbConfig c2(std::move(c1));
     REQUIRE(c2.getDacName(3) == "yetanothername");
 }
 
+TEST_CASE("Add or modify a register name", "[.reg]") {
+    CtbConfig c;
+    auto addr = RegisterAddress(100);
+    auto addr1 = RegisterAddress(300);
+
+    REQUIRE(c.getRegisterNamesCount() == 0);
+    REQUIRE_THROWS(
+        c.setRegisterName("reg1_with_a_really_long_name_to_crash", addr));
+    // add an entry
+    REQUIRE_NOTHROW(c.setRegisterName("reg1", addr));
+    REQUIRE(c.getRegisterName(addr) == "reg1");
+    REQUIRE(c.getRegisterAddress("reg1") == addr);
+    REQUIRE(c.getRegisterNamesCount() == 1);
+    // modify an entry
+    REQUIRE_NOTHROW(c.setRegisterName("reg1", addr1));
+    REQUIRE(c.getRegisterAddress("reg1") == addr1);
+    REQUIRE(c.getRegisterName(addr1) == "reg1");
+    // clear all entries
+    REQUIRE_NOTHROW(c.clearRegisterNames());
+    REQUIRE(c.getRegisterNamesCount() == 0);
+    REQUIRE_THROWS(c.getRegisterName(addr));
+    REQUIRE_THROWS(c.getRegisterAddress("reg1"));
+    REQUIRE_THROWS(c.getRegisterName(addr1));
+}
+
+TEST_CASE("Add a register list", "[.reg]") {
+    CtbConfig c;
+    REQUIRE(c.getRegisterNamesCount() == 0);
+
+    // add a list
+    std::map<std::string, RegisterAddress> list = {
+        {"reg1", RegisterAddress(0x100)},
+        {"reg2", RegisterAddress(0x200)},
+        {"reg3", RegisterAddress(0x300)}};
+    REQUIRE_NOTHROW(c.setRegisterNames(list));
+    REQUIRE(c.getRegisterNamesCount() == static_cast<int>(list.size()));
+    auto names = c.getRegisterNames();
+    REQUIRE(names.size() == 3);
+
+    // TODO std::set<RegisterAddress> seen_values;
+    for (const auto &[key, val] : list) {
+        // check for duplicate keys, and key-value match
+        REQUIRE(names.count(key) == 1);
+        REQUIRE(names.at(key) == val);
+
+        // check for duplicate values
+        // TODO REQUIRE(seen_values.count(val) == 0);
+        // TODO seen_values.insert(val);
+    }
+
+    // clear all entries
+    REQUIRE_NOTHROW(c.clearRegisterNames());
+    REQUIRE(c.getRegisterNames().size() == 0);
+}
+
+TEST_CASE("Finding a regiser name or address", "[.reg]") {
+    CtbConfig c;
+    RegisterAddress addr1(0x100);
+    RegisterAddress addr2(0x200);
+    RegisterAddress addr3(0x300);
+
+    // find nothing
+    REQUIRE(c.getRegisterNamesCount() == 0);
+    REQUIRE_THROWS(c.getRegisterName(addr1));
+    REQUIRE_THROWS(c.getRegisterAddress("reg1"));
+
+    std::map<std::string, RegisterAddress> list = {
+        {"reg1", addr1}, {"reg2", addr2}, {"reg3", addr3}};
+    REQUIRE_NOTHROW(c.setRegisterNames(list));
+
+    // find
+    REQUIRE(c.getRegisterName(addr1) == "reg1");
+    REQUIRE(c.getRegisterName(addr2) == "reg2");
+    REQUIRE(c.getRegisterAddress("reg3") == addr3);
+}
+
+TEST_CASE("Add or modify a bit name", "[.reg]") {
+    CtbConfig c;
+    RegisterAddress addr(0x100);
+    BitAddress pos(addr, 2);
+    BitAddress pos1(addr, 5);
+
+    REQUIRE(c.getBitNamesCount() == 0);
+
+    REQUIRE_THROWS(c.setBitName("bit1_with_a_really_long_name_to_crash",
+                                BitAddress(addr, 100)));
+    REQUIRE_THROWS(c.setBitName("bit1", BitAddress(addr, 32)));
+    REQUIRE_THROWS(c.setBitName("bit1", BitAddress(addr, -1)));
+
+    // add an entry
+    REQUIRE_NOTHROW(c.setBitName("bit1", pos));
+    REQUIRE(c.getBitName(pos) == "bit1");
+    REQUIRE(c.getBitAddress("bit1") == pos);
+    REQUIRE(c.getBitNamesCount() == 1);
+    // modify an entry
+    REQUIRE_NOTHROW(c.setBitName("bit1", pos1));
+    REQUIRE(c.getBitAddress("bit1") == pos1);
+    REQUIRE(c.getBitName(pos1) == "bit1");
+    // clear all entries
+    REQUIRE_NOTHROW(c.clearBitNames());
+    REQUIRE(c.getBitNamesCount() == 0);
+    REQUIRE_THROWS(c.getBitName(pos));
+    REQUIRE_THROWS(c.getBitAddress("bit1"));
+    REQUIRE_THROWS(c.getBitName(pos1));
+}
+
+TEST_CASE("Add a bit list", "[.reg]") {
+    CtbConfig c;
+    REQUIRE(c.getBitNamesCount() == 0);
+
+    RegisterAddress addr(0x100);
+    BitAddress pos1(addr, 2);
+    BitAddress pos2(addr, 21);
+
+    BitAddress pos3(addr, 31);
+
+    // add a list
+    std::map<std::string, BitAddress> list = {
+        {"bit1", pos1}, {"bit2", pos2}, {"bit3", pos3}};
+    REQUIRE_NOTHROW(c.setBitNames(list));
+    REQUIRE(c.getBitNamesCount() == 3);
+    auto names = c.getBitNames();
+    REQUIRE(names.size() == 3);
+
+    // TODO std::set<BitAddress> seen_values;
+    for (const auto &[key, val] : list) {
+        // check for duplicate keys, and key-value match
+        REQUIRE(names.count(key) == 1);
+        REQUIRE(names.at(key) == val);
+
+        // check for duplicate values
+        // TODO REQUIRE(seen_values.count(val) == 0);
+        // TODO seen_values.insert(val);
+    }
+
+    // clear all entries
+    REQUIRE_NOTHROW(c.clearBitNames());
+    REQUIRE(c.getBitNames().size() == 0);
+}
+
+TEST_CASE("Finding a bit value", "[.reg]") {
+    CtbConfig c;
+    RegisterAddress addr(0x100);
+    BitAddress pos(addr, 2);
+    BitAddress pos1(addr, 21);
+    BitAddress pos2(addr, 31);
+
+    // find nothing
+    REQUIRE(c.getBitNamesCount() == 0);
+    REQUIRE_THROWS(c.getBitAddress("bit"));
+
+    std::map<std::string, BitAddress> list = {
+        {"bit0", pos}, {"bit1", pos1}, {"bit2", pos2}};
+    REQUIRE_NOTHROW(c.setBitNames(list));
+
+    // find
+    REQUIRE(c.getBitAddress("bit2") == pos2);
+    REQUIRE(c.getBitName(pos1) == "bit1");
+}
+
 } // namespace sls

slsDetectorSoftware/tests/test-MapOnStack.cpp

@@ -0,0 +1,133 @@
+#include "MapOnStack.h"
+#include "catch.hpp"
+#include "sls/bit_utils.h"
+
+#include <string>
+
+namespace sls {
+
+using Key = FixedString<32>;
+
+TEST_CASE("MapOnStack with int values") {
+    MapOnStack<Key, int, 64, true> map;
+
+    map.addKey("bit0", 55);
+    map.addKeyOrSetValue("bit1", 66);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.capacity() == 64);
+    REQUIRE(map.empty() == false);
+
+    REQUIRE(map.getValue("bit0") == 55);
+    REQUIRE(map.getValue("bit1") == 66);
+
+    // Duplicate key throws
+    REQUIRE_THROWS(map.addKey("bit0", 77));
+    // Duplicate value throws
+    REQUIRE_THROWS(map.addKey("bit2", 66));
+
+    // modifies
+    map.addKeyOrSetValue("bit0", 77);
+    REQUIRE(map.getValue("bit0") == 77);
+
+    // containsKey / hasValue
+    REQUIRE(map.containsKey("bit1"));
+    REQUIRE(map.hasValue(77));
+
+    // Clear map
+    map.clear();
+    REQUIRE(map.empty());
+    REQUIRE(map.size() == 0);
+    REQUIRE(map.capacity() == 64);
+}
+
+TEST_CASE("MapOnStack with BitAddress values") {
+    MapOnStack<Key, BitAddress, 64, true> map;
+
+    RegisterAddress addr0(0x100);
+    RegisterAddress addr1(0x200);
+    BitAddress b0(addr0, 0);
+    BitAddress b1(addr0, 1);
+    BitAddress b2(addr1, 0);
+
+    map.addKey("bit0", b0);
+    map.addKeyOrSetValue("bit1", b1);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.capacity() == 64);
+    REQUIRE(map.empty() == false);
+
+    REQUIRE(map.getValue("bit0") == b0);
+    REQUIRE(map.getValue("bit1") == b1);
+
+    // Duplicate key throws
+    REQUIRE_THROWS(map.addKey("bit0", b2));
+    // Duplicate value throws
+    REQUIRE_THROWS(map.addKey("bit2", b1));
+
+    // modifies
+    map.addKeyOrSetValue("bit0", b2);
+    REQUIRE(map.getValue("bit0") == b2);
+
+    // containsKey / hasValue
+    REQUIRE(map.containsKey("bit1"));
+    REQUIRE(map.hasValue(b2));
+
+    // Clear map
+    map.clear();
+    REQUIRE(map.empty());
+    REQUIRE(map.size() == 0);
+    REQUIRE(map.capacity() == 64);
+}
+
+TEST_CASE("Set and get a single entry") {
+    MapOnStack<Key, RegisterAddress, 64, true> map;
+    RegisterAddress addr0(0x100);
+
+    map.addKey("bit0", addr0);
+    auto entries = map.getMap();
+    REQUIRE(entries.size() == 1);
+
+    REQUIRE(map.getValue("bit0") == addr0);
+    REQUIRE(entries["bit0"] == addr0);
+}
+
+TEST_CASE("Set a name that is too large throws") {
+    MapOnStack<Key, int, 64, true> map;
+    REQUIRE_THROWS(map.addKey("somestringthatisreallytolongforadatac", 12));
+}
+
+TEST_CASE("Length of dac name cannot be 0") {
+    MapOnStack<Key, int, 64, true> map;
+    REQUIRE_THROWS(map.addKey("", 12));
+}
+
+TEST_CASE("Copy a MapOnStack") {
+    MapOnStack<Key, int, 64, true> m1;
+    m1.addKey("key1", 12);
+
+    auto m2 = m1;
+    // change the first object
+    // to detecto shallow copy
+    m1.setValue("key1", 34);
+    REQUIRE(m2.getValue("key1") == 12);
+}
+
+TEST_CASE("Move MapOnStack ") {
+    MapOnStack<Key, int, 64, true> m1;
+    m1.addKey("key1", 12);
+    MapOnStack<Key, int, 64, true> m2(std::move(m1));
+    REQUIRE(m1.size() == 0);
+    REQUIRE(m2.size() == 1);
+}
+
+TEST_CASE("Set map from std::map") {
+    MapOnStack<Key, int, 64, true> map;
+    std::map<Key, int> m1 = {{"key1", 11}, {"key2", 22}, {"key3", 33}};
+    map.setMap(m1);
+    REQUIRE(map.size() == 3);
+    REQUIRE(map.getValue("key2") == 22);
+
+    auto retrieved_map = map.getMap();
+    REQUIRE(retrieved_map.size() == 3);
+    REQUIRE(retrieved_map["key3"] == 33);
+
+} // namespace sls

slsDetectorSoftware/tests/test-Module.cpp

@@ -10,7 +10,7 @@ namespace sls {
 using dt = slsDetectorDefs::detectorType;
 TEST_CASE("Construction with a defined detector type") {
     freeSharedMemory(0, 0); // clean up to start test
-    Module const m(dt::EIGER);
+    Module m(dt::EIGER);
     REQUIRE(m.getDetectorType() == dt::EIGER);
     freeSharedMemory(0, 0); // clean up
     SharedMemory<sharedModule> moduleShm(0, 0);
@@ -19,10 +19,10 @@ TEST_CASE("Construction with a defined detector type") {
 
 TEST_CASE("Read back detector type from shm") {
     // Create specific detector in order to create shm
-    Module const m(dt::JUNGFRAU);
+    Module m(dt::JUNGFRAU);
 
     // New detector that reads type from shm
-    Module const m2;
+    Module m2;
     REQUIRE(m2.getDetectorType() == dt::JUNGFRAU);
 
     // Now both objects point to the same shm so we can only
@@ -33,7 +33,7 @@ TEST_CASE("Read back detector type from shm") {
 }
 
 TEST_CASE("Is shm fixed pattern shm compatible") {
-    Module const m(dt::JUNGFRAU);
+    Module m(dt::JUNGFRAU);
 
     // Should be true since we just created the shm
     REQUIRE(m.isFixedPatternSharedMemoryCompatible() == true);
@@ -53,7 +53,7 @@ TEST_CASE("Is shm fixed pattern shm compatible") {
 }
 
 TEST_CASE("Get default control port") {
-    Module const m(dt::MYTHEN3);
+    Module m(dt::MYTHEN3);
     REQUIRE(m.getControlPort() == 1952);
     freeSharedMemory(0, 0);
     SharedMemory<sharedModule> moduleShm(0, 0);
@@ -61,7 +61,7 @@ TEST_CASE("Get default control port") {
 }
 
 TEST_CASE("Get default stop port") {
-    Module const m(dt::GOTTHARD2);
+    Module m(dt::GOTTHARD2);
     REQUIRE(m.getStopPort() == 1953);
     freeSharedMemory(0, 0);
     SharedMemory<sharedModule> moduleShm(0, 0);
@@ -69,7 +69,7 @@ TEST_CASE("Get default stop port") {
 }
 
 TEST_CASE("Get default receiver TCP port") {
-    Module const m(dt::MYTHEN3);
+    Module m(dt::MYTHEN3);
     REQUIRE(m.getReceiverPort() == 1954);
     freeSharedMemory(0, 0);
     SharedMemory<sharedModule> moduleShm(0, 0);

slsDetectorSoftware/tests/test-Pattern.cpp

@@ -20,7 +20,7 @@ TEST_CASE("Copy construct pattern") {
 }
 
 TEST_CASE("Compare patterns") {
-    Pattern const p;
+    Pattern p;
     Pattern p1;
     REQUIRE(p == p1);
 

slsDetectorSoftware/tests/test-Result.cpp

@@ -13,7 +13,7 @@ TEST_CASE("Result looks and behaves like a standard container") {
 }
 
 TEST_CASE("Default construction is possible and gives an empty result") {
-    Result<int> const res;
+    Result<int> res;
     REQUIRE(res.size() == 0);
     REQUIRE(res.empty() == true);
 }
@@ -38,7 +38,7 @@ TEST_CASE("Like vector it can be constructed from size and value") {
 }
 
 TEST_CASE("Result can be iterated using modern syntax") {
-    Result<int> const res{0, 1, 2, 3, 4, 5};
+    Result<int> res{0, 1, 2, 3, 4, 5};
 
     int i = 0;
     for (const auto &r : res)
@@ -46,28 +46,28 @@ TEST_CASE("Result can be iterated using modern syntax") {
 }
 
 TEST_CASE("Calling squash on an empty Result produces default value") {
-    Result<double> const res;
+    Result<double> res;
     REQUIRE(res.squash() == 0.);
 
-    Result<unsigned> const res2;
+    Result<unsigned> res2;
     REQUIRE(res2.squash() == 0u);
 
-    Result<std::string> const res3;
+    Result<std::string> res3;
     REQUIRE(res3.squash() == "");
 }
 
 TEST_CASE("When equal squash gives the front value") {
-    Result<int> const res{3, 3, 3};
+    Result<int> res{3, 3, 3};
     REQUIRE(res.squash() == 3);
 }
 
 TEST_CASE("When elements are not equal squash gives default value") {
-    Result<int> const res{3, 3, 3, 5};
+    Result<int> res{3, 3, 3, 5};
     REQUIRE(res.squash() == 0);
 }
 
 TEST_CASE("String compare with squash") {
-    Result<std::string> const res{"hej", "hej", "hej"};
+    Result<std::string> res{"hej", "hej", "hej"};
     REQUIRE(res.squash() == "hej");
 }
 
@@ -113,13 +113,13 @@ TEST_CASE("Check if elements are equal") {
 
 TEST_CASE("Result can be converted to std::vector") {
     Result<short> res{1, 2, 3, 4, 5};
-    std::vector<short> const vec{1, 2, 3, 4, 5};
-    std::vector<short> const vec2 = res;
+    std::vector<short> vec{1, 2, 3, 4, 5};
+    std::vector<short> vec2 = res;
     REQUIRE(vec2 == vec);
 }
 
 TEST_CASE("Result can be printed using <<") {
-    Result<int> const res{1, 2, 3};
+    Result<int> res{1, 2, 3};
     std::ostringstream os;
     os << res;
     REQUIRE(os.str() == "[1, 2, 3]");
@@ -139,8 +139,8 @@ TEST_CASE("Convert from Result<int> to Result<ns>") {
 
 TEST_CASE("Result of vectors") {
     using VecVec = std::vector<std::vector<int>>;
-    VecVec const vecvec{{1, 2, 3}, {4, 5, 6}};
-    Result<VecVec> const res{vecvec};
+    VecVec vecvec{{1, 2, 3}, {4, 5, 6}};
+    Result<VecVec> res{vecvec};
 }
 
 TEST_CASE("Free function begin end") {
@@ -159,30 +159,30 @@ TEST_CASE("Sorting a Result") {
 }
 
 TEST_CASE("Printing Result<std::string>") {
-    Result<std::string> const res{"ein", "zwei", "drei"};
+    Result<std::string> res{"ein", "zwei", "drei"};
     std::ostringstream os;
     os << res;
     REQUIRE(os.str() == "[ein, zwei, drei]");
 }
 
 TEST_CASE("Printing Result<int>") {
-    Result<int> const res{1, 2, 3};
+    Result<int> res{1, 2, 3};
     std::ostringstream os;
     os << res;
     REQUIRE(os.str() == "[1, 2, 3]");
 }
 
 TEST_CASE("String conversions") {
-    Result<int> const res{1, 2, 3};
+    Result<int> res{1, 2, 3};
     REQUIRE(ToString(res) == "[1, 2, 3]");
 
-    Result<std::string> const res2{"one", "two", "three"};
+    Result<std::string> res2{"one", "two", "three"};
     REQUIRE(ToString(res2) == "[one, two, three]");
 
     using Smap = std::map<std::string, std::string>;
     Smap m;
     m["one"] = "1";
-    Result<Smap> const res3{m, m, m};
+    Result<Smap> res3{m, m, m};
     REQUIRE(res3.size() == 3);
     REQUIRE(ToString(res3) == "[{one: 1}, {one: 1}, {one: 1}]");
 
@@ -191,25 +191,25 @@ TEST_CASE("String conversions") {
     m2["two"] = "2";
     m2["three"] = "3";
 
-    Result<Smap> const res4{m, m2, m};
+    Result<Smap> res4{m, m2, m};
     REQUIRE(ToString(res4) ==
             "[{one: 1}, {one: 1, three: 3, two: 2}, {one: 1}]");
 }
 
 TEST_CASE("Any element is equal") {
-    Result<int> const r{1, 2, 3, 4, 5};
+    Result<int> r{1, 2, 3, 4, 5};
     REQUIRE(r.any(3));
     REQUIRE_FALSE(r.any(9));
 }
 
 TEST_CASE("Result contains only the specified elements") {
-    Result<int> const r{1, 1, 1};
+    Result<int> r{1, 1, 1};
     REQUIRE(r.contains_only(1));
     REQUIRE(r.contains_only(1, 1));
 }
 
 TEST_CASE("Only with multiple values") {
-    Result<int> const r{1, 1, 2, 1, 2, 1, 1};
+    Result<int> r{1, 1, 2, 1, 2, 1, 1};
     REQUIRE_FALSE(r.contains_only(1));
     REQUIRE_FALSE(r.contains_only(2));
     REQUIRE(r.contains_only(1, 2));

slsDetectorSoftware/tests/test-SharedMemory.cpp

@@ -39,15 +39,13 @@ void freeShm(const int dindex, const int mIndex) {
 
 constexpr int shm_id = 10;
 
-//macOS does not expose shm in the filesystem
+// macOS does not expose shm in the filesystem
 #ifndef __APPLE__
 
 const std::string file_path =
     std::string("/dev/shm/slsDetectorPackage_detector_") +
     std::to_string(shm_id);
 
-
-
 TEST_CASE("Free obsolete (without isValid)", "[detector][shm]") {
 
     // ensure its clean to start
@@ -105,9 +103,9 @@ TEST_CASE("Create SharedMemory read and write", "[detector][shm]") {
     shm.createSharedMemory();
 
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
-    CHECK(shm.getName() == std::string(SHM_DETECTOR_PREFIX) +
-                               std::to_string(shm_id) + env_name);
+    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
+    CHECK(shm.getName() ==
+          std::string(SHM_DETECTOR_PREFIX) + std::to_string(shm_id) + env_name);
     shm()->x = 3;
     shm()->y = 5.7;
     strcpy_safe(shm()->mess, "Some string");
@@ -177,11 +175,11 @@ TEST_CASE("Open two shared memories to the same place", "[detector][shm]") {
 
 TEST_CASE("Move SharedMemory", "[detector][shm]") {
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
+    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
 
     SharedMemory<Data> shm(shm_id, -1);
-    CHECK(shm.getName() == std::string(SHM_DETECTOR_PREFIX) +
-                               std::to_string(shm_id) + env_name);
+    CHECK(shm.getName() ==
+          std::string(SHM_DETECTOR_PREFIX) + std::to_string(shm_id) + env_name);
     shm.createSharedMemory();
     shm()->x = 9;
 
@@ -191,14 +189,14 @@ TEST_CASE("Move SharedMemory", "[detector][shm]") {
     CHECK(shm2()->x == 9);
     REQUIRE_THROWS(
         shm()); // trying to access should throw instead of returning a nullptr
-    CHECK(shm2.getName() == std::string(SHM_DETECTOR_PREFIX) +
-                                std::to_string(shm_id) + env_name);
+    CHECK(shm2.getName() ==
+          std::string(SHM_DETECTOR_PREFIX) + std::to_string(shm_id) + env_name);
     shm2.removeSharedMemory();
 }
 
 TEST_CASE("Create several shared memories", "[detector][shm]") {
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
+    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
 
     constexpr int N = 5;
     std::vector<SharedMemory<Data>> v;
@@ -225,9 +223,9 @@ TEST_CASE("Create several shared memories", "[detector][shm]") {
 
 TEST_CASE("Create create a shared memory with a tag") {
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
+    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
 
-    SharedMemory<Data> const shm(0, -1, "ctbdacs");
+    SharedMemory<Data> shm(0, -1, "ctbdacs");
     REQUIRE(shm.getName() ==
             std::string(SHM_DETECTOR_PREFIX) + "0" + env_name + "_ctbdacs");
 }
@@ -242,8 +240,9 @@ TEST_CASE("Create create a shared memory with a tag when SLSDETNAME is set") {
     unsetenv(SHM_ENV_NAME);
     setenv(SHM_ENV_NAME, "myprefix", 1);
 
-    SharedMemory<Data> const shm(0, -1, "ctbdacs");
-    REQUIRE(shm.getName() == std::string(SHM_DETECTOR_PREFIX) + "0_myprefix_ctbdacs");
+    SharedMemory<Data> shm(0, -1, "ctbdacs");
+    REQUIRE(shm.getName() ==
+            std::string(SHM_DETECTOR_PREFIX) + "0_myprefix_ctbdacs");
 
     // Clean up after us
     if (old_slsdetname.empty())

slsReceiverSoftware/src/Arping.cpp

@@ -38,7 +38,7 @@ void Arping::SetInterfacesAndIps(const int index, const std::string &interface,
     // create commands to arping
     std::ostringstream os;
     os << "arping -c 1 -U -I " << interface << " " << ip;
-    std::string const cmd = os.str();
+    std::string cmd = os.str();
     commands[index] = cmd;
 }
 
@@ -84,7 +84,7 @@ void Arping::StopProcess() {
 
 void Arping::ProcessExecution() {
     while (true) {
-        std::string const error = ExecuteCommands();
+        std::string error = ExecuteCommands();
         // just print (was already tested at Process start)
         if (!error.empty()) {
             LOG(logERROR) << error;
@@ -101,7 +101,7 @@ void Arping::TestForErrors() {
             "Could not arping. Interface not set up in arping Process");
     }
     // test if arping commands throw an error
-    std::string const error = ExecuteCommands();
+    std::string error = ExecuteCommands();
     if (!error.empty()) {
         throw RuntimeError(error);
     }

slsReceiverSoftware/src/ClientInterface.cpp

@@ -57,14 +57,14 @@ std::string ClientInterface::getReceiverVersion() { return APIRECEIVER; }
 /***callback functions***/
 void ClientInterface::registerCallBackStartAcquisition(
     void (*func)(const startCallbackHeader, void *), void *arg) {
-    std::lock_guard<std::mutex> const lock(callbackMutex);
+    std::lock_guard<std::mutex> lock(callbackMutex);
     startAcquisitionCallBack = func;
     pStartAcquisition = arg;
 }
 
 void ClientInterface::registerCallBackAcquisitionFinished(
     void (*func)(const endCallbackHeader, void *), void *arg) {
-    std::lock_guard<std::mutex> const lock(callbackMutex);
+    std::lock_guard<std::mutex> lock(callbackMutex);
     acquisitionFinishedCallBack = func;
     pAcquisitionFinished = arg;
 }
@@ -73,7 +73,7 @@ void ClientInterface::registerCallBackRawDataReady(
     void (*func)(sls_receiver_header &, dataCallbackHeader, char *, size_t &,
                  void *),
     void *arg) {
-    std::lock_guard<std::mutex> const lock(callbackMutex);
+    std::lock_guard<std::mutex> lock(callbackMutex);
     rawDataReadyCallBack = func;
     pRawDataReady = arg;
 }
@@ -338,15 +338,15 @@ int ClientInterface::setup_receiver(Interface &socket) {
         // udp setup
         // update retvals only if detmac is not the same as in detector
         if (arg.udp_dstip != 0) {
-            MacAddr const r = setUdpIp(IpAddr(arg.udp_dstip));
-            MacAddr const detMac{arg.udp_dstmac};
+            MacAddr r = setUdpIp(IpAddr(arg.udp_dstip));
+            MacAddr detMac{arg.udp_dstmac};
             if (detMac != r) {
                 retvals[0] = r;
             }
         }
         if (arg.udp_dstip2 != 0) {
-            MacAddr const r = setUdpIp2(IpAddr(arg.udp_dstip2));
-            MacAddr const detMac{arg.udp_dstmac2};
+            MacAddr r = setUdpIp2(IpAddr(arg.udp_dstip2));
+            MacAddr detMac{arg.udp_dstmac2};
             if (detMac != r) {
                 retvals[1] = r;
             }
@@ -467,7 +467,7 @@ void ClientInterface::setDetectorType(detectorType arg) {
     }
     // callbacks after (in setdetectortype, the object is reinitialized)
     {
-        std::lock_guard<std::mutex> const lock(callbackMutex);
+        std::lock_guard<std::mutex> lock(callbackMutex);
         if (startAcquisitionCallBack != nullptr)
             impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,
                                                      pStartAcquisition);
@@ -586,8 +586,8 @@ int ClientInterface::set_num_digital_samples(Interface &socket) {
 int ClientInterface::set_exptime(Interface &socket) {
     int64_t args[2]{-1, -1};
     socket.Receive(args);
-    int const gateIndex = static_cast<int>(args[0]);
-    ns const value = std::chrono::nanoseconds(args[1]);
+    int gateIndex = static_cast<int>(args[0]);
+    ns value = std::chrono::nanoseconds(args[1]);
     LOG(logDEBUG1) << "Setting exptime to " << ToString(value)
                    << " (gateIndex: " << gateIndex << ")";
     switch (gateIndex) {
@@ -635,7 +635,7 @@ int ClientInterface::set_period(Interface &socket) {
 int ClientInterface::set_subexptime(Interface &socket) {
     auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
     LOG(logDEBUG1) << "Setting period to " << ToString(value);
-    ns const subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
+    ns subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
     impl()->setSubExpTime(value);
     impl()->setSubPeriod(impl()->getSubExpTime() + subdeadtime);
     return socket.Send(OK);
@@ -780,7 +780,7 @@ int ClientInterface::get_file_dir(Interface &socket) {
 }
 
 int ClientInterface::set_file_name(Interface &socket) {
-    std::string const fname = socket.Receive(MAX_STR_LENGTH);
+    std::string fname = socket.Receive(MAX_STR_LENGTH);
     if (fname.empty()) {
         throw RuntimeError("Cannot set empty file name");
     }
@@ -1115,7 +1115,7 @@ int ClientInterface::set_additional_json_header(Interface &socket) {
 }
 
 int ClientInterface::get_additional_json_header(Interface &socket) {
-    std::map<std::string, std::string> const json = impl()->getAdditionalJsonHeader();
+    std::map<std::string, std::string> json = impl()->getAdditionalJsonHeader();
     LOG(logDEBUG1) << "additional json header:" << ToString(json);
     std::ostringstream oss;
     for (auto &it : json) {
@@ -1319,7 +1319,7 @@ int ClientInterface::set_quad_type(Interface &socket) {
                                std::string(e.what()) + ']');
         }
     }
-    int const retval = impl()->getQuad() ? 1 : 0;
+    int retval = impl()->getQuad() ? 1 : 0;
     validate(quadEnable, retval, "set quad", DEC);
     LOG(logDEBUG1) << "quad retval:" << retval;
     return socket.Send(OK);
@@ -1336,7 +1336,7 @@ int ClientInterface::set_read_n_rows(Interface &socket) {
         LOG(logDEBUG1) << "Setting number of rows:" << arg;
         impl()->setReadNRows(arg);
     }
-    int const retval = impl()->getReadNRows();
+    int retval = impl()->getReadNRows();
     validate(arg, retval, "set number of rows", DEC);
     LOG(logDEBUG1) << "read number of rows:" << retval;
     return socket.Send(OK);
@@ -1516,7 +1516,7 @@ int ClientInterface::set_additional_json_parameter(Interface &socket) {
 }
 
 int ClientInterface::get_additional_json_parameter(Interface &socket) {
-    std::string const key = socket.Receive(SHORT_STR_LENGTH);
+    std::string key = socket.Receive(SHORT_STR_LENGTH);
     std::string value = impl()->getAdditionalJsonParameter(key);
     value.resize(SHORT_STR_LENGTH);
     return socket.sendResult(value);
@@ -1541,7 +1541,7 @@ int ClientInterface::set_num_gates(Interface &socket) {
 int ClientInterface::set_gate_delay(Interface &socket) {
     int64_t args[2]{-1, -1};
     socket.Receive(args);
-    int const gateIndex = static_cast<int>(args[0]);
+    int gateIndex = static_cast<int>(args[0]);
     auto value = std::chrono::nanoseconds(args[1]);
     LOG(logDEBUG1) << "Setting gate delay to " << ToString(value)
                    << " (gateIndex: " << gateIndex << ")";
@@ -1657,7 +1657,7 @@ int ClientInterface::set_all_threshold(Interface &socket) {
 int ClientInterface::set_detector_datastream(Interface &socket) {
     int args[2]{-1, -1};
     socket.Receive(args);
-    portPosition const port = static_cast<portPosition>(args[0]);
+    portPosition port = static_cast<portPosition>(args[0]);
     switch (port) {
     case LEFT:
     case RIGHT:
@@ -1665,7 +1665,7 @@ int ClientInterface::set_detector_datastream(Interface &socket) {
     default:
         throw RuntimeError("Invalid port type");
     }
-    bool const enable = static_cast<int>(args[1]);
+    bool enable = static_cast<int>(args[1]);
     LOG(logDEBUG1) << "Setting datastream (" << ToString(port) << ") to "
                    << ToString(enable);
     if (detType != EIGER)

slsReceiverSoftware/src/CommandLineOptions.cpp

@@ -21,7 +21,7 @@ ParsedOptions CommandLineOptions::parse(const std::vector<std::string> &args) {
     for (const auto &arg : args) {
         argv.push_back(const_cast<char *>(arg.c_str()));
     }
-    int const argc = static_cast<int>(argv.size());
+    int argc = static_cast<int>(argv.size());
     return parse(argc, argv.data());
 }
 
@@ -76,7 +76,7 @@ ParsedOptions CommandLineOptions::parse(int argc, char *argv[]) {
         }
 
         // parse deprecated arguments
-        std::vector<std::string> const args(argv, argv + argc);
+        std::vector<std::string> args(argv, argv + argc);
         auto [p, n, o] = ParseDeprecated(args);
         // set options
         base.port = p;
@@ -251,7 +251,7 @@ void CommandLineOptions::handleAppSpecificOption(int opt, const char *optarg,
 std::tuple<uint16_t, uint16_t, bool>
 CommandLineOptions::ParseDeprecated(const std::vector<std::string> &args) {
 
-    size_t const nargs = args.size();
+    size_t nargs = args.size();
     if (nargs != 1 && nargs != 3 && nargs != 4) {
         throw sls::RuntimeError("Invalid number of arguments.");
     }
@@ -266,8 +266,8 @@ CommandLineOptions::ParseDeprecated(const std::vector<std::string> &args) {
     }
 
     // parse deprecated arguments
-    uint16_t const p = parsePort(args[1].c_str());
-    uint16_t const n = parseNumReceivers(args[2].c_str());
+    uint16_t p = parsePort(args[1].c_str());
+    uint16_t n = parseNumReceivers(args[2].c_str());
     bool o = false;
     if (nargs == 4) {
         try {

slsReceiverSoftware/src/DataProcessor.cpp

@@ -93,7 +93,7 @@ void DataProcessor::SetNumberofTotalFrames(uint64_t value) {
 
 void DataProcessor::SetAdditionalJsonHeader(
     const std::map<std::string, std::string> &json) {
-    std::lock_guard<std::mutex> const lock(additionalJsonMutex);
+    std::lock_guard<std::mutex> lock(additionalJsonMutex);
     additionalJsonHeader = json;
     isAdditionalJsonUpdated = true;
 }
@@ -254,7 +254,7 @@ std::string DataProcessor::CreateMasterFile(
 
     attr->framesInFile = numFramesCaught;
 
-    std::unique_ptr<File> const masterFile{nullptr};
+    std::unique_ptr<File> masterFile{nullptr};
     switch (fileFormatType) {
 #ifdef HDF5C
     case HDF5:
@@ -325,11 +325,11 @@ void DataProcessor::StopProcessing(char *buf) {
 void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
                                    size_t &firstImageIndex, char *data) {
 
-    uint64_t const fnum = header.detHeader.frameNumber;
+    uint64_t fnum = header.detHeader.frameNumber;
     LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
     currentFrameIndex = fnum;
     numFramesCaught++;
-    uint32_t const nump = header.detHeader.packetNumber;
+    uint32_t nump = header.detHeader.packetNumber;
 
     if (!startedFlag) {
         RecordFirstIndex(fnum);
@@ -390,16 +390,16 @@ void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
         // callbacks
         if (rawDataReadyCallBack != nullptr) {
 
-            uint64_t const frameIndex = fnum - firstIndex;
+            uint64_t frameIndex = fnum - firstIndex;
             // update local copy only if it was updated (to prevent locking each
             // time)
             if (isAdditionalJsonUpdated) {
-                std::lock_guard<std::mutex> const lock(additionalJsonMutex);
+                std::lock_guard<std::mutex> lock(additionalJsonMutex);
                 localAdditionalJsonHeader = additionalJsonHeader;
                 isAdditionalJsonUpdated = false;
             }
 
-            dataCallbackHeader const callbackHeader = {
+            dataCallbackHeader callbackHeader = {
                 udpPortNumber,
                 {static_cast<int>(generalData->nPixelsX),
                  static_cast<int>(generalData->nPixelsY)},
@@ -446,7 +446,7 @@ bool DataProcessor::CheckTimer() {
 
     auto elapsed_s = (end.tv_sec - timerbegin.tv_sec) +
                      (end.tv_nsec - timerbegin.tv_nsec) / 1e9;
-    double const timer_s = streamingTimerInMs / 1e3;
+    double timer_s = streamingTimerInMs / 1e3;
 
     LOG(logDEBUG1) << index << " Timer elapsed time:" << elapsed_s
                    << " seconds";
@@ -480,7 +480,7 @@ void DataProcessor::registerCallBackRawDataReady(
 void DataProcessor::PadMissingPackets(sls_receiver_header header, char *data) {
     LOG(logDEBUG) << index << ": Padding Missing Packets";
 
-    uint32_t const pperFrame = generalData->packetsPerFrame;
+    uint32_t pperFrame = generalData->packetsPerFrame;
 
     uint32_t nmissing = pperFrame - header.detHeader.packetNumber;
     sls_bitset pmask = header.packetsMask;
@@ -489,7 +489,7 @@ void DataProcessor::PadMissingPackets(sls_receiver_header header, char *data) {
     if (generalData->detType == GOTTHARD2 && index != 0) {
         dsize = generalData->vetoDataSize;
     }
-    uint32_t const corrected_dsize =
+    uint32_t corrected_dsize =
         dsize - ((pperFrame * dsize) - generalData->imageSize);
     LOG(logDEBUG1) << "bitmask: " << pmask.to_string();
 
@@ -571,7 +571,7 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
     const auto ctbDbitList = generalData->ctbDbitList;
 
     // TODO! (Erik) Refactor and add tests
-    int const ctbDigitalDataBytes = nDigitalDataBytes - ctbDbitOffset;
+    int ctbDigitalDataBytes = nDigitalDataBytes - ctbDbitOffset;
 
     // no digital data
     if (ctbDigitalDataBytes == 0) {
@@ -618,13 +618,13 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
                 ++dest;
             }
 
-            uint8_t const byte_index = bi / 8;
+            uint8_t byte_index = bi / 8;
 
             // loop through the frame digital data
             for (auto *ptr = source + byte_index;
                  ptr < (source + 8 * numDigitalSamples); ptr += 8) {
                 // get selected bit from each 8 bit
-                uint8_t const bit = (*ptr >> bi % 8) & 1;
+                uint8_t bit = (*ptr >> bi % 8) & 1;
                 *dest |= bit << bitoffset; // stored as least significant
                 ++bitoffset;
                 // extract destination in 8 bit batches
@@ -648,9 +648,9 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
             // loop through digital bit enable vector
             for (auto bi : ctbDbitList) {
                 // get selected bit from each 64 bit
-                uint8_t const byte_index = bi / 8;
+                uint8_t byte_index = bi / 8;
 
-                uint8_t const bit = (*(ptr + byte_index) >> (bi % 8)) & 1;
+                uint8_t bit = (*(ptr + byte_index) >> (bi % 8)) & 1;
                 *dest |= bit << bitoffset;
                 ++bitoffset;
                 // extract destination in 8 bit batches
@@ -684,12 +684,12 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
 
 void DataProcessor::CropImage(size_t &size, char *data) {
     LOG(logDEBUG1) << "Cropping Image to ROI " << ToString(portRoi);
-    int const nPixelsX = generalData->nPixelsX;
-    int const xmin = portRoi.xmin;
-    int const xmax = portRoi.xmax;
+    int nPixelsX = generalData->nPixelsX;
+    int xmin = portRoi.xmin;
+    int xmax = portRoi.xmax;
     int ymin = portRoi.ymin;
-    int const ymax = portRoi.ymax;
-    int const xwidth = xmax - xmin + 1;
+    int ymax = portRoi.ymax;
+    int xwidth = xmax - xmin + 1;
     int ywidth = ymax - ymin + 1;
     if (ymin == -1 || ymax == -1) {
         ywidth = 1;
@@ -697,11 +697,11 @@ void DataProcessor::CropImage(size_t &size, char *data) {
     }
 
     // calculate total roi size
-    double const bytesPerPixel = generalData->dynamicRange / 8.00;
-    int const startOffset = (int)((nPixelsX * ymin + xmin) * bytesPerPixel);
+    double bytesPerPixel = generalData->dynamicRange / 8.00;
+    int startOffset = (int)((nPixelsX * ymin + xmin) * bytesPerPixel);
 
     // write size into memory
-    std::size_t const roiImageSize = xwidth * ywidth * bytesPerPixel;
+    std::size_t roiImageSize = xwidth * ywidth * bytesPerPixel;
     LOG(logDEBUG) << "roiImageSize:" << roiImageSize;
     size = roiImageSize;
 

slsReceiverSoftware/src/DataStreamer.cpp

@@ -48,7 +48,7 @@ void DataStreamer::SetNumberofTotalFrames(uint64_t value) {
 
 void DataStreamer::SetAdditionalJsonHeader(
     const std::map<std::string, std::string> &json) {
-    std::lock_guard<std::mutex> const lock(additionalJsonMutex);
+    std::lock_guard<std::mutex> lock(additionalJsonMutex);
     additionalJsonHeader = json;
     isAdditionalJsonUpdated = true;
 }
@@ -77,7 +77,7 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, size_t firstImageIndex) {
 }
 
 void DataStreamer::CreateZmqSockets(uint16_t port, int hwm) {
-    uint16_t const portnum = port + index;
+    uint16_t portnum = port + index;
     try {
         zmqSocket = new ZmqSocket(portnum);
 
@@ -149,7 +149,7 @@ void DataStreamer::StopProcessing(char *buf) {
 void DataStreamer::ProcessAnImage(sls_detector_header header, size_t size,
                                   char *data) {
 
-    uint64_t const fnum = header.frameNumber;
+    uint64_t fnum = header.frameNumber;
     LOG(logDEBUG1) << "DataStreamer " << index << ": fnum:" << fnum;
 
     if (!SendDataHeader(header, size, generalData->nPixelsX,
@@ -177,8 +177,8 @@ int DataStreamer::SendDataHeader(sls_detector_header header, uint32_t size,
     zHeader.data = true;
     zHeader.jsonversion = SLS_DETECTOR_JSON_HEADER_VERSION;
 
-    uint64_t const frameIndex = header.frameNumber - firstIndex;
-    uint64_t const acquisitionIndex = header.frameNumber;
+    uint64_t frameIndex = header.frameNumber - firstIndex;
+    uint64_t acquisitionIndex = header.frameNumber;
 
     zHeader.dynamicRange = generalData->dynamicRange;
     zHeader.fileIndex = fileIndex;
@@ -212,7 +212,7 @@ int DataStreamer::SendDataHeader(sls_detector_header header, uint32_t size,
 
     // update local copy only if it was updated (to prevent locking each time)
     if (isAdditionalJsonUpdated) {
-        std::lock_guard<std::mutex> const lock(additionalJsonMutex);
+        std::lock_guard<std::mutex> lock(additionalJsonMutex);
         localAdditionalJsonHeader = additionalJsonHeader;
         isAdditionalJsonUpdated = false;
     }

slsReceiverSoftware/src/Fifo.cpp

@@ -41,13 +41,13 @@ void Fifo::CreateFifos(size_t fifoItemSize) {
     fifoFree = new CircularFifo<char>(fifoDepth);
     fifoStream = new CircularFifo<char>(fifoDepth);
     // allocate memory
-    size_t const mem_len = fifoItemSize * (size_t)fifoDepth * sizeof(char);
+    size_t mem_len = fifoItemSize * (size_t)fifoDepth * sizeof(char);
     memory = (char *)malloc(mem_len);
     if (memory == nullptr) {
         throw RuntimeError("Could not allocate memory for fifos");
     }
     memset(memory, 0, mem_len);
-    int const pagesize = getpagesize();
+    int pagesize = getpagesize();
     for (size_t i = 0; i < mem_len; i += pagesize) {
         strcpy(memory + i, "memory");
     }
@@ -84,14 +84,14 @@ void Fifo::DestroyFifos() {
 void Fifo::FreeAddress(char *&address) { fifoFree->push(address); }
 
 void Fifo::GetNewAddress(char *&address) {
-    int const temp = fifoFree->getDataValue();
+    int temp = fifoFree->getDataValue();
     if (temp < status_fifoFree)
         status_fifoFree = temp;
     fifoFree->pop(address);
 }
 
 void Fifo::PushAddress(char *&address) {
-    int const temp = fifoBound->getDataValue();
+    int temp = fifoBound->getDataValue();
     if (temp > status_fifoBound)
         status_fifoBound = temp;
     while (!fifoBound->push(address))
@@ -108,13 +108,13 @@ void Fifo::PushAddressToStream(char *&address) { fifoStream->push(address); }
 void Fifo::PopAddressToStream(char *&address) { fifoStream->pop(address); }
 
 int Fifo::GetMaxLevelForFifoBound() {
-    int const temp = status_fifoBound;
+    int temp = status_fifoBound;
     status_fifoBound = 0;
     return temp;
 }
 
 int Fifo::GetMinLevelForFifoFree() {
-    int const temp = status_fifoFree;
+    int temp = status_fifoFree;
     status_fifoFree = fifoDepth;
     return temp;
 }

slsReceiverSoftware/src/FrameSynchronizerApp.cpp

@@ -65,7 +65,7 @@ FrameStatus *global_frame_status = nullptr;
 
 void cleanup() {
     if (global_frame_status) {
-        std::lock_guard<std::mutex> const lock(global_frame_status->mtx);
+        std::lock_guard<std::mutex> lock(global_frame_status->mtx);
         for (auto &outer_pair : global_frame_status->frames) {
             for (auto &inner_pair : outer_pair.second) {
                 for (zmq_msg_t *msg : inner_pair.second) {
@@ -146,11 +146,11 @@ std::set<uint64_t> get_valid_fnums(const PortFrameMap &port_frame_map) {
 }
 
 int zmq_send_multipart(void *socket, const ZmqMsgList &messages) {
-    size_t const num_messages = messages.size();
+    size_t num_messages = messages.size();
     for (size_t i = 0; i != num_messages; ++i) {
         zmq_msg_t *msg = messages[i];
         // determine flags: ZMQ_SNDMORE for all messages except the last
-        int const flags = (i == num_messages - 1) ? 0 : ZMQ_SNDMORE;
+        int flags = (i == num_messages - 1) ? 0 : ZMQ_SNDMORE;
         if (zmq_msg_send(msg, socket, flags) == -1) {
             LOG(sls::logERROR)
                 << "Error sending message: " << zmq_strerror(zmq_errno());
@@ -164,7 +164,7 @@ void Correlate(FrameStatus *stat) {
     void *context = zmq_ctx_new();
 
     void *socket = zmq_socket(context, ZMQ_PUSH);
-    int const rc = zmq_bind(socket, "tcp://*:5555");
+    int rc = zmq_bind(socket, "tcp://*:5555");
     if (rc != 0) {
         LOG(sls::logERROR) << "failed to bind";
     }
@@ -172,7 +172,7 @@ void Correlate(FrameStatus *stat) {
     while (true) {
         sem_wait(&(stat->available));
         {
-            std::lock_guard<std::mutex> const lock(stat->mtx);
+            std::lock_guard<std::mutex> lock(stat->mtx);
 
             if (stat->terminate) {
                 break;
@@ -304,10 +304,10 @@ void StartAcquisitionCallback(
     }
     oss << "}\n";
 
-    std::string const message = oss.str();
+    std::string message = oss.str();
     LOG(sls::logDEBUG) << "Start Acquisition message:" << std::endl << message;
 
-    int const length = message.length();
+    int length = message.length();
     char *hdata = new char[length];
     memcpy(hdata, message.c_str(), length);
     zmq_msg_t *hmsg = new zmq_msg_t;
@@ -316,7 +316,7 @@ void StartAcquisitionCallback(
     // push zmq msg into stat to be processed
     FrameStatus *stat = static_cast<FrameStatus *>(objectPointer);
     {
-        std::lock_guard<std::mutex> const lock(stat->mtx);
+        std::lock_guard<std::mutex> lock(stat->mtx);
         stat->headers.push_back(hmsg);
         stat->starting = true;
         // clean up old frames
@@ -355,8 +355,8 @@ void AcquisitionFinishedCallback(
         << sls::ToString(callbackHeader.completeFrames)
         << ", \"lastFrameIndex\":"
         << sls::ToString(callbackHeader.lastFrameIndex) << "}\n";
-    std::string const message = oss.str();
-    int const length = message.length();
+    std::string message = oss.str();
+    int length = message.length();
     LOG(sls::logDEBUG) << "Acquisition Finished message:" << std::endl
                        << message;
 
@@ -368,7 +368,7 @@ void AcquisitionFinishedCallback(
     // push zmq msg into stat to be processed
     FrameStatus *stat = static_cast<FrameStatus *>(objectPointer);
     {
-        std::lock_guard<std::mutex> const lock(stat->mtx);
+        std::lock_guard<std::mutex> lock(stat->mtx);
         stat->ends.push_back(hmsg);
     }
     sem_post(&stat->available);
@@ -379,7 +379,7 @@ void GetDataCallback(slsDetectorDefs::sls_receiver_header &header,
                      char *dataPointer, size_t &imageSize,
                      void *objectPointer) {
 
-    slsDetectorDefs::sls_detector_header const detectorHeader = header.detHeader;
+    slsDetectorDefs::sls_detector_header detectorHeader = header.detHeader;
 
     if (printHeadersLevel < sls::logDEBUG) {
         // print in different color for each udp port
@@ -468,11 +468,11 @@ void GetDataCallback(slsDetectorDefs::sls_receiver_header &header,
         oss << " } ";
     }
     oss << "}\n";
-    std::string const message = oss.str();
+    std::string message = oss.str();
     LOG(sls::logDEBUG) << "Data message:" << std::endl << message;
 
     // creating header part of data packet
-    int const length = message.length();
+    int length = message.length();
     char *hdata = new char[length];
     memcpy(hdata, message.c_str(), length);
     zmq_msg_t *hmsg = new zmq_msg_t;
@@ -486,7 +486,7 @@ void GetDataCallback(slsDetectorDefs::sls_receiver_header &header,
     // push both parts into stat to be processed
     FrameStatus *stat = static_cast<FrameStatus *>(objectPointer);
     {
-        std::lock_guard<std::mutex> const lock(stat->mtx);
+        std::lock_guard<std::mutex> lock(stat->mtx);
         stat->frames[callbackHeader.udpPort][header.detHeader.frameNumber]
             .push_back(hmsg);
         stat->frames[callbackHeader.udpPort][header.detHeader.frameNumber]
@@ -544,7 +544,7 @@ int main(int argc, char *argv[]) {
 
     std::exception_ptr threadException = nullptr;
     for (int i = 0; i != f.numReceivers; ++i) {
-        uint16_t const port = f.port + i;
+        uint16_t port = f.port + i;
         sem_t *semaphore = &semaphores[i];
         threads.emplace_back(
             [i, semaphore, port, user_data, &threadException]() {
@@ -581,7 +581,7 @@ int main(int argc, char *argv[]) {
     cleanup();
 
     {
-        std::lock_guard<std::mutex> const lock(stat.mtx);
+        std::lock_guard<std::mutex> lock(stat.mtx);
         stat.terminate = true;
         sem_post(&stat.available);
     }

slsReceiverSoftware/src/Implementation.cpp

@@ -238,9 +238,9 @@ const slsDetectorDefs::xy Implementation::GetPortGeometry() const {
 }
 
 void Implementation::setDetectorSize(const slsDetectorDefs::xy size) {
-    xy const portGeometry = GetPortGeometry();
+    xy portGeometry = GetPortGeometry();
 
-    std::string const log_message = "Detector Size (ports): (";
+    std::string log_message = "Detector Size (ports): (";
     numModules = size;
     numPorts.x = portGeometry.x * numModules.x;
     numPorts.y = portGeometry.y * numModules.y;
@@ -262,7 +262,7 @@ void Implementation::setModulePositionId(const int id) {
     LOG(logINFO) << "Module Position Id:" << modulePos;
 
     // update zmq port
-    xy const portGeometry = GetPortGeometry();
+    xy portGeometry = GetPortGeometry();
     streamingPort = DEFAULT_ZMQ_RX_PORTNO + modulePos * portGeometry.x;
 
     assert(numModules.y != 0);
@@ -285,14 +285,14 @@ void Implementation::setModulePositionId(const int id) {
 
 void Implementation::setRow(const int value) {
     for (unsigned int i = 0; i < listener.size(); ++i) {
-        int const col = listener[i]->GetHardCodedPosition().second;
+        int col = listener[i]->GetHardCodedPosition().second;
         listener[i]->SetHardCodedPosition(value, col);
     }
 }
 
 void Implementation::setColumn(const int value) {
     for (unsigned int i = 0; i < listener.size(); ++i) {
-        int const row = listener[i]->GetHardCodedPosition().first;
+        int row = listener[i]->GetHardCodedPosition().first;
         listener[i]->SetHardCodedPosition(row, value);
     }
 }
@@ -405,16 +405,16 @@ std::vector<slsDetectorDefs::ROI> Implementation::getPortROIs() const {
 }
 
 void Implementation::ResetRois() {
-    int const numports = generalData->numUDPInterfaces;
-    std::vector<ROI> const rois(numports);
-    std::vector<ROI> const multiRoi(1);
+    int numports = generalData->numUDPInterfaces;
+    std::vector<ROI> rois(numports);
+    std::vector<ROI> multiRoi(1);
     setPortROIs(rois);
     setMultiROIMetadata(multiRoi);
 }
 
 void Implementation::setPortROIs(const std::vector<defs::ROI> &args) {
-    int const nx = static_cast<int>(generalData->nPixelsX);
-    int const ny = static_cast<int>(generalData->nPixelsY);
+    int nx = static_cast<int>(generalData->nPixelsX);
+    int ny = static_cast<int>(generalData->nPixelsY);
     // validate rois
     for (auto &it : args) {
         if (it.completeRoi() || it.noRoi()) {
@@ -614,7 +614,7 @@ double Implementation::getProgress() const {
 std::vector<int64_t> Implementation::getNumMissingPackets() const {
     std::vector<int64_t> mp(generalData->numUDPInterfaces);
     for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
-        int const np = generalData->packetsPerFrame;
+        int np = generalData->packetsPerFrame;
         uint64_t totnp = np;
         // ReadNRows
         if (readNRows != (int)generalData->maxRowsPerReadout) {
@@ -646,7 +646,7 @@ void Implementation::startReceiver() {
             for (size_t i = 0; i != listener.size(); ++i) {
                 udpPort.push_back(udpPortNum[i]);
             }
-            startCallbackHeader const callbackHeader = {
+            startCallbackHeader callbackHeader = {
                 udpPort,
                 generalData->dynamicRange,
                 numPorts,
@@ -731,7 +731,7 @@ void Implementation::stopReceiver() {
         // print summary
         uint64_t tot = 0;
         for (int i = 0; i < generalData->numUDPInterfaces; i++) {
-            int const nf = listener[i]->GetNumCompleteFramesCaught();
+            int nf = listener[i]->GetNumCompleteFramesCaught();
             tot += nf;
             std::string mpMessage = std::to_string(mp[i]);
             if (mp[i] < 0) {
@@ -756,7 +756,7 @@ void Implementation::stopReceiver() {
                 summary = os.str();
             }
 
-            TLogLevel const lev = ((mp[i]) > 0) ? logINFORED : logINFOGREEN;
+            TLogLevel lev = ((mp[i]) > 0) ? logINFORED : logINFOGREEN;
             LOG(lev) << "Summary of Port " << udpPortNum[i] << " (" << eth[i]
                      << ')' << summary;
         }
@@ -774,7 +774,7 @@ void Implementation::stopReceiver() {
                     lastFrameIndexCaught.push_back(
                         listener[i]->GetLastFrameIndexCaught());
                 }
-                endCallbackHeader const callHeader = {udpPort, completeFramesCaught,
+                endCallbackHeader callHeader = {udpPort, completeFramesCaught,
                                                 lastFrameIndexCaught};
                 acquisitionFinishedCallBack(callHeader, pAcquisitionFinished);
             } catch (const std::exception &e) {
@@ -852,7 +852,7 @@ void Implementation::ResetParametersforNewAcquisition() {
     if (dataStreamEnable) {
         std::ostringstream os;
         os << filePath << '/' << fileName;
-        std::string const fnametostream = os.str();
+        std::string fnametostream = os.str();
         for (const auto &it : dataStreamer)
             it->ResetParametersforNewAcquisition(fnametostream);
     }
@@ -884,7 +884,7 @@ void Implementation::SetupWriter() {
             std::ostringstream os;
             os << filePath << "/" << fileName << "_d"
                << (modulePos * generalData->numUDPInterfaces + i);
-            std::string const fileNamePrefix = os.str();
+            std::string fileNamePrefix = os.str();
             dataProcessor[i]->CreateFirstFiles(fileNamePrefix, fileIndex,
                                                overwriteEnable, silentMode,
                                                detectorDataStream[i]);
@@ -919,8 +919,8 @@ void Implementation::StartMasterWriter() {
             // complete ROI (for each port TODO?)
             if (multiRoiMetadata.size() == 1 &&
                 multiRoiMetadata[0].completeRoi()) {
-                int const nTotalPixelsX = (generalData->nPixelsX * numPorts.x);
-                int const nTotalPixelsY = (generalData->nPixelsY * numPorts.y);
+                int nTotalPixelsX = (generalData->nPixelsX * numPorts.x);
+                int nTotalPixelsY = (generalData->nPixelsY * numPorts.y);
                 if (nTotalPixelsY == 1) {
                     masterAttributes.rois.push_back(ROI{0, nTotalPixelsX - 1});
                 } else {
@@ -1180,7 +1180,7 @@ int Implementation::getUDPSocketBufferSize() const {
 }
 
 void Implementation::setUDPSocketBufferSize(const int s) {
-    size_t const listSize = listener.size();
+    size_t listSize = listener.size();
     if ((generalData->detType == JUNGFRAU || generalData->detType == MOENCH ||
          generalData->detType == GOTTHARD2) &&
         (int)listSize != generalData->numUDPInterfaces) {
@@ -1572,7 +1572,7 @@ void Implementation::setCounterMask(const uint32_t i) {
         SetupFifoStructure();
     }
     LOG(logINFO) << "Counter mask: " << ToStringHex(generalData->counterMask);
-    int const ncounters = __builtin_popcount(generalData->counterMask);
+    int ncounters = __builtin_popcount(generalData->counterMask);
     LOG(logINFO) << "Number of counters: " << ncounters;
 }
 
@@ -1661,13 +1661,13 @@ void Implementation::setActivate(bool enable) {
 }
 
 bool Implementation::getDetectorDataStream(const portPosition port) const {
-    int const index = (port == LEFT ? 0 : 1);
+    int index = (port == LEFT ? 0 : 1);
     return detectorDataStream[index];
 }
 
 void Implementation::setDetectorDataStream(const portPosition port,
                                            const bool enable) {
-    int const index = (port == LEFT ? 0 : 1);
+    int index = (port == LEFT ? 0 : 1);
     detectorDataStream10GbE[index] = enable;
     LOG(logINFO) << "Detector 10GbE datastream (" << ToString(port)
                  << " Port): " << ToString(detectorDataStream10GbE[index]);

slsReceiverSoftware/src/Listener.cpp

@@ -193,10 +193,10 @@ void Listener::DeleteUDPSocket() {
 void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int &actualSize) {
     // custom setup (s != 0)
     // default setup at startup (s = 0)
-    int const size = (s == 0 ? generalData->udpSocketBufferSize : s);
+    int size = (s == 0 ? generalData->udpSocketBufferSize : s);
     LOG(logINFO) << "Testing UDP Socket Buffer size " << size
                  << " with test port " << udpPortNumber;
-    int const previousSize = generalData->udpSocketBufferSize;
+    int previousSize = generalData->udpSocketBufferSize;
     generalData->udpSocketBufferSize = size;
 
     if (disabledPort) {
@@ -217,7 +217,7 @@ void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int &actualSize) {
         std::string ip;
         if (eth.length() > 0)
             ip = InterfaceNameToIp(eth).str();
-        UdpRxSocket const g(udpPortNumber, packetSize,
+        UdpRxSocket g(udpPortNumber, packetSize,
                       (ip.empty() ? nullptr : ip.c_str()),
                       generalData->udpSocketBufferSize);
 
@@ -268,7 +268,7 @@ void Listener::ThreadExecution() {
 
     // reset header and size and get data
     memset(memImage, 0, IMAGE_STRUCTURE_HEADER_SIZE);
-    int const rc = ListenToAnImage(memImage->header, memImage->data);
+    int rc = ListenToAnImage(memImage->header, memImage->data);
 
     // end of acquisition or discarding image
     if (rc <= 0) {
@@ -320,9 +320,9 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header &dstHeader,
         hsize = generalData->vetoHsize;
         standardHeader = false;
     }
-    uint32_t const pperFrame = generalData->packetsPerFrame;
+    uint32_t pperFrame = generalData->packetsPerFrame;
     bool isHeaderEmpty = true;
-    uint32_t const corrected_dsize = dsize - ((pperFrame * dsize) - imageSize);
+    uint32_t corrected_dsize = dsize - ((pperFrame * dsize) - imageSize);
     sls_detector_header *srcDetHeader = nullptr;
 
     // carry over packet
@@ -516,9 +516,9 @@ void Listener::PrintFifoStatistics() {
                    << " packetsperframe:" << generalData->packetsPerFrame;
 
     // calculate packet loss
-    int64_t const totalP = numFramesStatistic * (generalData->packetsPerFrame);
-    int64_t const loss = totalP - numPacketsStatistic;
-    int const lossPercent = ((double)loss / (double)totalP) * 100.00;
+    int64_t totalP = numFramesStatistic * (generalData->packetsPerFrame);
+    int64_t loss = totalP - numPacketsStatistic;
+    int lossPercent = ((double)loss / (double)totalP) * 100.00;
     numPacketsStatistic = 0;
     numFramesStatistic = 0;
 

slsReceiverSoftware/src/MasterAttributes.cpp

@@ -756,7 +756,7 @@ void MasterAttributes::WriteHDF5Version(H5::H5File *fd) {
 #endif
 
 void MasterAttributes::WriteBinaryTimestamp(writer *w) {
-    time_t const t = std::time(nullptr);
+    time_t t = std::time(nullptr);
     std::string sTime(ctime(&t));
     std::replace(sTime.begin(), sTime.end(), '\n', '\0');
     WriteBinary(w, N_TIMESTAMP.data(), sTime);

slsReceiverSoftware/src/MultiReceiverApp.cpp

@@ -76,7 +76,7 @@ void GetData(slsDetectorDefs::sls_receiver_header &header,
              slsDetectorDefs::dataCallbackHeader callbackHeader,
              char *dataPointer, size_t &imageSize, void *objectPointer) {
 
-    slsDetectorDefs::sls_detector_header const detectorHeader = header.detHeader;
+    slsDetectorDefs::sls_detector_header detectorHeader = header.detHeader;
 
     PRINT_IN_COLOR(
         (callbackHeader.udpPort % 10),
@@ -169,7 +169,7 @@ int main(int argc, char *argv[]) {
     for (int i = 0; i < m.numReceivers; ++i) {
 
         /**	- fork process to create child process */
-        pid_t const pid = fork();
+        pid_t pid = fork();
 
         /**	- if fork failed, raise SIGINT and properly destroy all child
          * processes */
@@ -185,7 +185,7 @@ int main(int argc, char *argv[]) {
                 << "Child process " << i << " [ Tid: " << gettid() << ']';
 
             try {
-                uint16_t const port = m.port + i;
+                uint16_t port = m.port + i;
                 sls::Receiver receiver(port);
 
                 /**	- register callbacks. remember to set file write enable
@@ -236,7 +236,7 @@ int main(int argc, char *argv[]) {
     /** - Parent process waits for all child processes to exit */
     for (;;) {
         int status;
-        pid_t const childPid = waitpid(-1, &status, 0);
+        pid_t childPid = waitpid(-1, &status, 0);
 
         // no child closed
         if (childPid == -1) {

slsReceiverSoftware/src/ReceiverApp.cpp

@@ -54,7 +54,7 @@ int main(int argc, char *argv[]) {
     sem_init(&semaphore, 1, 0);
 
     try {
-        sls::Receiver const r(o.port);
+        sls::Receiver r(o.port);
         LOG(sls::logINFO) << "[ Press \'Ctrl+c\' to exit ]";
         sem_wait(&semaphore);
         sem_destroy(&semaphore);

slsReceiverSoftware/tests/test-Apps.cpp

@@ -14,19 +14,19 @@ template <typename T, typename U> constexpr bool is_type() {
 }
 
 TEST_CASE("CommandLineOption construction", "[detector]") {
-    CommandLineOptions const s(AppType::SingleReceiver);
+    CommandLineOptions s(AppType::SingleReceiver);
     REQUIRE(s.getTypeString() == "slsReceiver");
     REQUIRE(s.getVersion() ==
             std::string("slsReceiver Version: ") + APIRECEIVER);
     REQUIRE_NOTHROW(s.getHelpMessage());
 
-    CommandLineOptions const m(AppType::MultiReceiver);
+    CommandLineOptions m(AppType::MultiReceiver);
     REQUIRE(m.getTypeString() == "slsMultiReceiver");
     REQUIRE(m.getVersion() ==
             std::string("slsMultiReceiver Version: ") + APIRECEIVER);
     REQUIRE_NOTHROW(m.getHelpMessage());
 
-    CommandLineOptions const f(AppType::FrameSynchronizer);
+    CommandLineOptions f(AppType::FrameSynchronizer);
     REQUIRE(f.getTypeString() == "slsFrameSynchronizer");
     REQUIRE(f.getVersion() ==
             std::string("slsFrameSynchronizer Version: ") + APIRECEIVER);
@@ -49,7 +49,7 @@ TEST_CASE("Parse Help", "[detector]") {
 }
 
 TEST_CASE("Validate common options", "[detector]") {
-    std::string const uidStr = std::to_string(getuid());
+    std::string uidStr = std::to_string(getuid());
 
     for (auto app : {AppType::SingleReceiver, AppType::MultiReceiver,
                      AppType::FrameSynchronizer}) {
@@ -65,7 +65,7 @@ TEST_CASE("Validate common options", "[detector]") {
 }
 
 TEST_CASE("Validate specific options", "[detector]") {
-    std::string const uidStr = std::to_string(getuid());
+    std::string uidStr = std::to_string(getuid());
 
     CommandLineOptions s(AppType::SingleReceiver);
     REQUIRE_NOTHROW(s.parse({"", "-t", "1955"}));
@@ -141,17 +141,16 @@ TEST_CASE("Parse version and help", "[detector]") {
 // TODO: fails on gitea CI due to uid issue, fix later
 TEST_CASE("Parse port and uid", "[.failsongitea][detector]") {
     uid_t uid = getuid();
-    std::string const uidStr = std::to_string(uid);
-    uid_t const invalidUid = uid + 1000;
-    std::string const invalidUidStr = std::to_string(invalidUid);
+    std::string uidStr = std::to_string(uid);
+    uid_t invalidUid = uid + 1000;
+    std::string invalidUidStr = std::to_string(invalidUid);
 
     for (auto app : {AppType::SingleReceiver, AppType::MultiReceiver,
                      AppType::FrameSynchronizer}) {
         CommandLineOptions s(app);
 
-        // TODO! This test fails on gitea CI probably because the user can set the uid
-        // commenting it out for now. Revisit later.
-        // REQUIRE_THROWS(
+        // TODO! This test fails on gitea CI probably because the user can set
+        // the uid commenting it out for now. Revisit later. REQUIRE_THROWS(
         //     s.parse({"", "-p", "1234", "-u", invalidUidStr})); // invalid uid
 
         REQUIRE_THROWS(s.parse({"", "-p", "500"})); // invalid port

slsReceiverSoftware/tests/test-ArrangeDataBasedOnBitList.cpp

@@ -109,9 +109,9 @@ class DataProcessorTestFixture {
 
     void set_data(const std::bitset<8> pattern = 0xFF) {
         delete[] data;
-        uint64_t const max_bytes_per_bit =
+        uint64_t max_bytes_per_bit =
             num_samples % 8 == 0 ? num_samples / 8 : num_samples / 8 + 1;
-        uint64_t const reserved_size =
+        uint64_t reserved_size =
             get_size() - num_digital_bytes + max_bytes_per_bit * 64;
         data = new char[reserved_size];
 
@@ -148,7 +148,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Remove Trailing Bits",
 
     generaldata->SetCtbDbitOffset(num_random_offset_bytes);
 
-    size_t const expected_size = get_size() - num_random_offset_bytes;
+    size_t expected_size = get_size() - num_random_offset_bytes;
 
     char *expected_data = new char[expected_size];
     memset(expected_data, dummy_value, num_analog_bytes); // set to 125
@@ -287,7 +287,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder false",
     set_num_samples(num_samples);
     set_data(0b01010101); // set digital data to 0x55 to have alternating bits
 
-    size_t const expected_size =
+    size_t expected_size =
         num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
 
     // create expected data
@@ -343,7 +343,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder true",
     set_num_samples(num_samples);
     set_data(0b01010101);
 
-    size_t const expected_size =
+    size_t expected_size =
         num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
 
     // create expected data
@@ -371,8 +371,8 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
                  "Arrange bitlist and remove trailing bits",
                  "[.dataprocessor][.retrievebitlist]") {
 
-    size_t const num_random_offset_bytes = 3;
-    std::vector<int> const bitlist{1, 4, 5};
+    size_t num_random_offset_bytes = 3;
+    std::vector<int> bitlist{1, 4, 5};
 
     set_random_offset_bytes(num_random_offset_bytes);
     set_data();
@@ -386,7 +386,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
     std::vector<uint8_t> expected_digital_part{0b00000111};
     const size_t expected_num_digital_bytes = 5;
 
-    size_t const expected_size =
+    size_t expected_size =
         num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
 
     // create expected data

slsSupportLib/CMakeLists.txt

@@ -17,6 +17,7 @@ set(SOURCES
     src/sls_detector_exceptions.cpp
     src/md5_helper.cpp
     src/Version.cpp
+    src/bit_utils.cpp
 )
 
 # Header files to install as a part of the library
@@ -29,6 +30,7 @@ set(PUBLICHEADERS
     include/sls/ToString.h
     include/sls/TypeTraits.h
     include/sls/TimeHelper.h
+    include/sls/bit_utils.h
 )
 
 # Additional headers to be installed if SLS_DEVEL_HEADERS

slsSupportLib/include/sls/ToString.h

@@ -11,6 +11,7 @@
 
 #include "sls/TimeHelper.h"
 #include "sls/TypeTraits.h"
+#include "sls/bit_utils.h"
 #include "sls/sls_detector_defs.h"
 #include "sls/sls_detector_exceptions.h"
 #include "sls/string_utils.h"
@@ -65,6 +66,7 @@ std::ostream &operator<<(std::ostream &os,
 std::string ToString(const slsDetectorDefs::pedestalParameters &r);
 std::ostream &operator<<(std::ostream &os,
                          const slsDetectorDefs::pedestalParameters &r);
+
 const std::string &ToString(const std::string &s);
 
 /** Convert std::chrono::duration with specified output unit */
@@ -324,6 +326,8 @@ template <> defs::gainMode StringTo(const std::string &s);
 template <> defs::polarity StringTo(const std::string &s);
 template <> defs::timingInfoDecoder StringTo(const std::string &s);
 template <> defs::collectionMode StringTo(const std::string &s);
+template <> RegisterAddress StringTo(const std::string &s);
+template <> RegisterValue StringTo(const std::string &s);
 
 template <> uint8_t StringTo(const std::string &s);
 template <> uint16_t StringTo(const std::string &s);

slsSupportLib/include/sls/bit_utils.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <bitset>
+#include <cstdint>
 #include <vector>
 namespace sls {
 template <typename T> std::vector<int> getSetBits(T val) {
@@ -18,4 +19,87 @@ template <typename T> std::vector<int> getSetBits(T val) {
     }
     return set_bits;
 }
+
+class RegisterAddress {
+  private:
+    uint32_t value_{0};
+
+  public:
+    constexpr RegisterAddress() noexcept = default;
+    constexpr explicit RegisterAddress(uint32_t value) : value_(value) {}
+    std::string str() const;
+    constexpr uint32_t value() const noexcept { return value_; }
+
+    constexpr bool operator==(const RegisterAddress &other) const {
+        return (value_ == other.value_);
+    }
+    constexpr bool operator!=(const RegisterAddress &other) const {
+        return (value_ != other.value_);
+    }
+};
+
+class BitAddress {
+  private:
+    RegisterAddress addr_{0};
+    uint32_t bitPos_{0};
+
+  public:
+    constexpr BitAddress() noexcept = default;
+    BitAddress(RegisterAddress address, uint32_t bitPosition);
+    std::string str() const;
+    constexpr RegisterAddress address() const noexcept { return addr_; }
+    constexpr uint32_t bitPosition() const noexcept { return bitPos_; }
+
+    constexpr bool operator==(const BitAddress &other) const {
+        return (addr_ == other.addr_ && bitPos_ == other.bitPos_);
+    }
+    constexpr bool operator!=(const BitAddress &other) const {
+        return !(*this == other);
+    }
+};
+
+class RegisterValue {
+  private:
+    uint32_t value_{0};
+
+  public:
+    constexpr RegisterValue() noexcept = default;
+    explicit constexpr RegisterValue(uint32_t value) noexcept : value_(value) {}
+    std::string str() const;
+    constexpr uint32_t value() const noexcept { return value_; }
+
+    constexpr RegisterValue &operator|=(const RegisterValue &rhs) noexcept {
+        value_ |= rhs.value();
+        return *this;
+    }
+
+    constexpr RegisterValue operator|(const RegisterValue &rhs) const noexcept {
+        RegisterValue tmp(*this);
+        tmp |= rhs;
+        return tmp;
+    }
+
+    constexpr RegisterValue &operator|=(uint32_t rhs) noexcept {
+        value_ |= rhs;
+        return *this;
+    }
+
+    constexpr RegisterValue operator|(uint32_t rhs) const noexcept {
+        RegisterValue tmp(*this);
+        tmp |= rhs;
+        return tmp;
+    }
+
+    constexpr bool operator==(const RegisterValue &other) const noexcept {
+        return value_ == other.value_;
+    }
+    constexpr bool operator!=(const RegisterValue &other) const noexcept {
+        return value_ != other.value_;
+    }
+};
+
+std::ostream &operator<<(std::ostream &os, const RegisterAddress &r);
+std::ostream &operator<<(std::ostream &os, const BitAddress &r);
+std::ostream &operator<<(std::ostream &os, const RegisterValue &r);
+
 } // namespace sls

slsSupportLib/include/sls/container_utils.h

@@ -181,20 +181,18 @@ typename std::enable_if<is_container<T>::value, bool>::type
 stableRemoveDuplicates(T &c) {
     auto containerSize = c.size();
     std::set<typename T::value_type> seen;
-    c.erase(
-        std::remove_if(c.begin(), c.end(),
-            [&](const typename T::value_type& val) {
+    c.erase(std::remove_if(
+                c.begin(), c.end(),
+                [&](const typename T::value_type &val) {
                     return !seen.insert(val).second; // erase if already seen
                 }),
-        c.end()
-    );
+            c.end());
     if (c.size() != containerSize) {
         return true;
     }
     return false;
 }
 
-
 } // namespace sls
 
 #endif // CONTAINER_UTILS_H

slsSupportLib/include/sls/sls_detector_defs.h

@@ -788,9 +788,9 @@ typedef struct {
 
     explicit sls_detector_module(slsDetectorDefs::detectorType type)
         : sls_detector_module() {
-        const detParameters parameters{type}; //used to initialize
-        const int nch = parameters.nChanX * parameters.nChanY;
-        const int nc = parameters.nChipX * parameters.nChipY;
+        detParameters parameters{type};
+        int nch = parameters.nChanX * parameters.nChanY;
+        int nc = parameters.nChipX * parameters.nChipY;
         ndac = parameters.nDacs;
         nchip = nc;
         nchan = nch * nc;
@@ -804,6 +804,8 @@ typedef struct {
     }
 
     sls_detector_module &operator=(const sls_detector_module &other) {
+        if(this == &other)
+            return *this;
         delete[] dacs;
         delete[] chanregs;
         serialnumber = other.serialnumber;

slsSupportLib/include/sls/string_utils.h

@@ -5,6 +5,7 @@
 #include <cassert>
 #include <cstdint>
 #include <cstring>
+#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
@@ -33,6 +34,35 @@ void strcpy_safe(char (&destination)[array_size], const std::string &source) {
     destination[array_size - 1] = '\0';
 }
 
+// Runtime-checked variant — throws if it won't fit
+template <size_t array_size>
+void strcpy_checked(char (&destination)[array_size], const char *source) {
+    if (!source)
+        throw std::runtime_error("Null source pointer in strcpy_checked");
+
+    size_t len = std::strlen(source);
+    if (len >= (array_size - 1)) {
+        throw std::runtime_error("String length (" + std::to_string(len) +
+                                 ") should be less than " +
+                                 std::to_string(array_size - 1) + " chars");
+    }
+    std::strncpy(destination, source, array_size - 1);
+    destination[array_size - 1] = '\0';
+}
+
+template <size_t array_size>
+void strcpy_checked(char (&destination)[array_size],
+                    const std::string &source) {
+    if (source.size() >= (array_size - 1)) {
+        throw std::runtime_error("String length (" +
+                                 std::to_string(source.size()) +
+                                 ") should be less than " +
+                                 std::to_string(array_size - 1) + " chars");
+    }
+    std::strncpy(destination, source.c_str(), array_size - 1);
+    destination[array_size - 1] = '\0';
+}
+
 /*
 Removes all occurrences of the specified char from a c string
 Templated on array size to ensure no access after buffer limits.
@@ -58,6 +88,8 @@ std::vector<std::string> split(const std::string &strToSplit, char delimeter);
 std::string RemoveUnit(std::string &str);
 
 bool is_int(const std::string &s);
+/** '0x200' is also an int here */
+bool is_hex_or_dec_uint(const std::string &s);
 
 bool replace_first(std::string *s, const std::string &substr,
                    const std::string &repl);

slsSupportLib/include/sls/versionAPI.h

@@ -7,6 +7,6 @@
 #define APIGOTTHARD2 "0.0.0 0x250909"
 #define APIMOENCH    "0.0.0 0x250909"
 #define APIEIGER     "0.0.0 0x250909"
-#define APIXILINXCTB "0.0.0 0x251015"
+#define APIXILINXCTB "0.0.0 0x260105"
 #define APIJUNGFRAU  "0.0.0 0x250909"
 #define APIMYTHEN3   "0.0.0 0x250922"

slsSupportLib/src/ClientSocket.cpp

@@ -24,7 +24,7 @@ ClientSocket::ClientSocket(std::string stype, const std::string &host,
     hints.ai_flags |= AI_CANONNAME;
 
     if (getaddrinfo(host.c_str(), nullptr, &hints, &result) != 0) {
-        std::string const msg = "ClientSocket cannot decode host:" + host +
+        std::string msg = "ClientSocket cannot decode host:" + host +
                           " on port " + std::to_string(port) + "\n";
         throw SocketError(msg);
     }
@@ -40,7 +40,7 @@ ClientSocket::ClientSocket(std::string stype, const std::string &host,
     if (::connect(getSocketId(), (struct sockaddr *)&serverAddr,
                   sizeof(serverAddr)) != 0) {
         freeaddrinfo(result);
-        std::string const msg = "ClientSocket: Cannot connect to " + socketType +
+        std::string msg = "ClientSocket: Cannot connect to " + socketType +
                           ":" + host + " on port " + std::to_string(port) +
                           "\n";
         throw SocketError(msg);
@@ -54,7 +54,7 @@ ClientSocket::ClientSocket(std::string sType, struct sockaddr_in addr)
     if (::connect(getSocketId(), (struct sockaddr *)&addr, sizeof(addr)) != 0) {
         char address[INET_ADDRSTRLEN];
         inet_ntop(AF_INET, &addr.sin_addr, address, INET_ADDRSTRLEN);
-        std::string const msg = "ClientSocket: Cannot connect to " + socketType +
+        std::string msg = "ClientSocket: Cannot connect to " + socketType +
                           ":" + address + " on port " +
                           std::to_string(addr.sin_port) + "\n";
         throw SocketError(msg);
@@ -77,7 +77,7 @@ void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) {
     try {
         Receive(&ret, sizeof(ret));
         if (ret == slsDetectorDefs::FAIL) {
-            std::string const mess = readErrorMessage();
+            std::string mess = readErrorMessage();
             // Do we need to know hostname here?
             // In that case save it???
             if (socketType == "Receiver") {

slsSupportLib/src/DataSocket.cpp

@@ -48,7 +48,7 @@ void DataSocket::setFnum(const int fnum) { fnum_ = fnum; }
 
 int DataSocket::Receive(void *buffer, size_t size) {
     // TODO!(Erik) Add sleep? how many reties?
-    int const bytes_expected = static_cast<int>(size); // signed size
+    int bytes_expected = static_cast<int>(size); // signed size
     int bytes_read = 0;
     while (bytes_read < bytes_expected) {
         auto this_read =
@@ -79,7 +79,7 @@ std::string DataSocket::Receive(size_t length) {
 }
 int DataSocket::Send(const void *buffer, size_t size) {
     int bytes_sent = 0;
-    int const data_size = static_cast<int>(size); // signed size
+    int data_size = static_cast<int>(size); // signed size
     while (bytes_sent < (data_size)) {
         auto this_send = ::write(getSocketId(), buffer, size);
         if (this_send <= 0)

slsSupportLib/src/ServerSocket.cpp

@@ -47,7 +47,7 @@ ServerInterface ServerSocket::accept() {
     lastClient = thisClient; // update from previous connection
     struct sockaddr_in clientAddr;
     socklen_t addr_size = sizeof clientAddr;
-    int const newSocket =
+    int newSocket =
         ::accept(getSocketId(), (struct sockaddr *)&clientAddr, &addr_size);
     if (newSocket == -1) {
         throw SocketError("Server ERROR: socket accept failed\n");

slsSupportLib/src/ToString.cpp

@@ -614,7 +614,7 @@ std::string ToString(const defs::portPosition s) {
 
 std::string ToString(const defs::streamingInterface s) {
     std::ostringstream os;
-    std::string const rs;
+    std::string rs;
     switch (s) {
     case defs::streamingInterface::NONE:
         return std::string("none");
@@ -1128,8 +1128,8 @@ template <> defs::collectionMode StringTo(const std::string &s) {
 }
 
 template <> uint8_t StringTo(const std::string &s) {
-    int const base = s.find("0x") != std::string::npos ? 16 : 10;
-    int const value = std::stoi(s, nullptr, base);
+    int base = s.find("0x") != std::string::npos ? 16 : 10;
+    int value = std::stoi(s, nullptr, base);
     if (value < std::numeric_limits<uint8_t>::min() ||
         value > std::numeric_limits<uint8_t>::max()) {
         throw RuntimeError("Cannot scan uint8_t from string '" + s +
@@ -1139,8 +1139,8 @@ template <> uint8_t StringTo(const std::string &s) {
 }
 
 template <> uint16_t StringTo(const std::string &s) {
-    int const base = s.find("0x") != std::string::npos ? 16 : 10;
-    int const value = std::stoi(s, nullptr, base);
+    int base = s.find("0x") != std::string::npos ? 16 : 10;
+    int value = std::stoi(s, nullptr, base);
     if (value < std::numeric_limits<uint16_t>::min() ||
         value > std::numeric_limits<uint16_t>::max()) {
         throw RuntimeError("Cannot scan uint16_t from string '" + s +
@@ -1150,22 +1150,22 @@ template <> uint16_t StringTo(const std::string &s) {
 }
 
 template <> uint32_t StringTo(const std::string &s) {
-    int const base = s.find("0x") != std::string::npos ? 16 : 10;
+    int base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoul(s, nullptr, base);
 }
 
 template <> uint64_t StringTo(const std::string &s) {
-    int const base = s.find("0x") != std::string::npos ? 16 : 10;
+    int base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoull(s, nullptr, base);
 }
 
 template <> int StringTo(const std::string &s) {
-    int const base = s.find("0x") != std::string::npos ? 16 : 10;
+    int base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoi(s, nullptr, base);
 }
 
 template <> bool StringTo(const std::string &s) {
-    int const i = std::stoi(s, nullptr, 10);
+    int i = std::stoi(s, nullptr, 10);
     switch (i) {
     case 0:
         return false;
@@ -1177,7 +1177,7 @@ template <> bool StringTo(const std::string &s) {
 }
 
 template <> int64_t StringTo(const std::string &s) {
-    int const base = s.find("0x") != std::string::npos ? 16 : 10;
+    int base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stol(s, nullptr, base);
 }
 

slsSupportLib/src/ZmqSocket.cpp

@@ -305,8 +305,8 @@ int ZmqSocket::SendHeader(int index, zmqHeader header) {
     oss << ", \"rx_roi\":[" << header.rx_roi[0] << ", " << header.rx_roi[1]
         << ", " << header.rx_roi[2] << ", " << header.rx_roi[3] << "]";
     oss << "}\n";
-    std::string const message = oss.str();
-    int const length = message.length();
+    std::string message = oss.str();
+    int length = message.length();
 #ifdef ZMQ_DETAIL
     // if(!index)
     LOG(logINFOBLUE) << index << " : Streamer: buf: " << message;
@@ -436,7 +436,7 @@ int ZmqSocket::ParseHeader(const int index, int length, char *buff,
 int ZmqSocket::ReceiveData(const int index, char *buf, const int size) {
     zmq_msg_t message;
     zmq_msg_init(&message);
-    int const length = ReceiveMessage(index, message);
+    int length = ReceiveMessage(index, message);
     if (length == size) {
         memcpy(buf, (char *)zmq_msg_data(&message), size);
     } else if (length < size) {
@@ -453,7 +453,7 @@ int ZmqSocket::ReceiveData(const int index, char *buf, const int size) {
 }
 
 int ZmqSocket::ReceiveMessage(const int index, zmq_msg_t &message) {
-    int const length = zmq_msg_recv(&message, sockfd.socketDescriptor, 0);
+    int length = zmq_msg_recv(&message, sockfd.socketDescriptor, 0);
     if (length == -1) {
         PrintError();
         LOG(logERROR) << "Could not read header for socket " << index;

slsSupportLib/src/bit_utils.cpp

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#include "sls/bit_utils.h"
+#include "sls/ToString.h"
+#include "sls/sls_detector_exceptions.h"
+
+namespace sls {
+
+std::string RegisterAddress::str() const { return ToStringHex(value_); }
+
+BitAddress::BitAddress(RegisterAddress address, uint32_t bitPosition)
+    : addr_(address) {
+    if (bitPosition > 31) {
+        throw RuntimeError("Bit position must be between 0 and 31.");
+    }
+    bitPos_ = bitPosition;
+}
+
+std::string BitAddress::str() const {
+    std::ostringstream os;
+    os << '[' << addr_.str() << ", " << ToString(bitPos_) << ']';
+    return os.str();
+}
+
+std::string RegisterValue::str() const { return ToStringHex(value_); }
+
+std::ostream &operator<<(std::ostream &os, const RegisterAddress &r) {
+    os << r.str();
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const BitAddress &r) {
+    os << r.str();
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const RegisterValue &r) {
+    os << r.str();
+    return os;
+}
+
+} // namespace sls

slsSupportLib/src/file_utils.cpp

@@ -52,7 +52,7 @@ int readDataFile(std::ifstream &infile, short int *data, int nch, int offset) {
 int readDataFile(std::string fname, short int *data, int nch) {
     std::ifstream infile;
     int iline = 0;
-    std::string const str;
+    std::string str;
     infile.open(fname.c_str(), std::ios_base::in);
     if (infile.is_open()) {
         iline = readDataFile(infile, data, nch, 0);
@@ -80,7 +80,7 @@ std::vector<char> readBinaryFile(const std::string &fname,
     }
 
     // get file size to print progress
-    ssize_t const filesize = getFileSize(fp, errorPrefix);
+    ssize_t filesize = getFileSize(fp, errorPrefix);
 
     std::vector<char> buffer(filesize, 0);
     if ((ssize_t)fread(buffer.data(), sizeof(char), filesize, fp) != filesize) {
@@ -142,14 +142,14 @@ void mkdir_p(const std::string &path, std::string dir) {
 int getFileSize(std::ifstream &ifs) {
     auto current_pos = ifs.tellg();
     ifs.seekg(0, std::ios::end);
-    int const file_size = ifs.tellg();
+    int file_size = ifs.tellg();
     ifs.seekg(current_pos);
     return file_size;
 }
 
 std::string getFileNameFromFilePath(const std::string &fpath) {
     std::string fname(fpath);
-    std::size_t const slashPos = fpath.rfind('/');
+    std::size_t slashPos = fpath.rfind('/');
     if (slashPos != std::string::npos) {
         fname = fpath.substr(slashPos + 1, fpath.size() - 1);
     }
@@ -161,7 +161,7 @@ ssize_t getFileSize(FILE *fd, const std::string &prependErrorString) {
         throw RuntimeError(prependErrorString +
                            std::string(" (Seek error in src file)"));
     }
-    size_t const fileSize = ftell(fd);
+    size_t fileSize = ftell(fd);
     if (fileSize <= 0) {
         throw RuntimeError(
             prependErrorString +
@@ -181,7 +181,7 @@ getChannelsFromStringList(const std::vector<std::string> list) {
             begin(line), end(line), [](char c) { return (c == ','); }, ' ');
 
         // split line (delim space)
-        std::vector<std::string> const vec = split(line, ' ');
+        std::vector<std::string> vec = split(line, ' ');
 
         // for every channel separated by space
         for (auto it : vec) {
@@ -189,8 +189,8 @@ getChannelsFromStringList(const std::vector<std::string> list) {
             auto result = it.find(':');
             if (result != std::string::npos) {
                 try {
-                    int const istart = StringTo<int>(it.substr(0, result));
-                    int const istop = StringTo<int>(
+                    int istart = StringTo<int>(it.substr(0, result));
+                    int istop = StringTo<int>(
                         it.substr(result + 1, it.length() - result - 1));
                     LOG(logDEBUG1) << "istart:" << istart << " istop:" << istop;
                     std::vector<int> range(istop - istart);
@@ -256,12 +256,11 @@ std::string getAbsolutePathFromCurrentProcess(const std::string &fname) {
         return fname;
     }
 
-    //in case PATH_MAX defines the longest possible path on linux and macOS
-    //use string instead of char array to avoid overflow
+    // in case PATH_MAX defines the longest possible path on linux and macOS
+    // use string instead of char array to avoid overflow
     std::string path(PATH_MAX, '\0');
 
-
-    #if defined(__APPLE__)
+#if defined(__APPLE__)
     uint32_t size = PATH_MAX;
     if (_NSGetExecutablePath(path.data(), &size) != 0) {
         throw std::runtime_error("Failed to get executable path");
@@ -272,16 +271,15 @@ std::string getAbsolutePathFromCurrentProcess(const std::string &fname) {
         throw std::runtime_error("realpath failed for executable");
     }
     path = resolved;
-    #else
+#else
 
-
-    ssize_t const len = readlink("/proc/self/exe", path.data(), PATH_MAX - 1);
+    ssize_t len = readlink("/proc/self/exe", path.data(), PATH_MAX - 1);
     if (len < 0) {
         throw RuntimeError("Could not get absolute path for " + fname);
     }
     path[len] = '\0';
 
-    #endif
+#endif
 
     // get dir path and attach file name
     std::string absPath = (std::string(dirname(path.data())) + '/' + fname);

slsSupportLib/src/network_utils.cpp

@@ -115,7 +115,7 @@ IpAddr HostnameToIp(const char *hostname) {
         throw RuntimeError("Could not convert hostname (" +
                            std::string(hostname) + ") to ip");
     }
-    uint32_t const ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
+    uint32_t ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
     freeaddrinfo(result);
     return IpAddr(ip);
 }
@@ -179,8 +179,7 @@ IpAddr InterfaceNameToIp(const std::string &ifn) {
 MacAddr InterfaceNameToMac(const std::string &inf) {
 
 #ifdef __APPLE__
-    throw RuntimeError(
-        "InterfaceNameToMac not implemented on macOS yet");
+    throw RuntimeError("InterfaceNameToMac not implemented on macOS yet");
 #else
 
     // TODO! Copied from genericSocket needs to be refactored!
@@ -189,7 +188,7 @@ MacAddr InterfaceNameToMac(const std::string &inf) {
     const int mac_len = sizeof(mac);
     memset(mac, 0, mac_len);
 
-    int const sock = socket(PF_INET, SOCK_STREAM, 0);
+    int sock = socket(PF_INET, SOCK_STREAM, 0);
     strncpy(ifr.ifr_name, inf.c_str(), sizeof(ifr.ifr_name) - 1);
     ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 

slsSupportLib/src/string_utils.cpp

@@ -43,6 +43,15 @@ bool is_int(const std::string &s) {
                          }) == s.end();
 }
 
+bool is_hex_or_dec_uint(const std::string &s) {
+    try {
+        StringTo<uint32_t>(s);
+        return true;
+    } catch (...) {
+    }
+    return false;
+}
+
 bool replace_first(std::string *s, const std::string &substr,
                    const std::string &repl) {
     auto pos = s->find(substr);

slsSupportLib/tests/test-StaticVector.cpp

@@ -15,9 +15,9 @@ TEST_CASE("StaticVector is a container") {
 }
 
 TEST_CASE("Comparing StaticVector containers") {
-    StaticVector<int, 5> const a{0, 1, 2};
-    StaticVector<int, 5> const b{0, 1, 2};
-    StaticVector<int, 5> const c{0, 1, 2, 4};
+    StaticVector<int, 5> a{0, 1, 2};
+    StaticVector<int, 5> b{0, 1, 2};
+    StaticVector<int, 5> c{0, 1, 2, 4};
 
     REQUIRE(a == b);
     REQUIRE_FALSE(a != b);
@@ -29,9 +29,9 @@ TEST_CASE("Comparing StaticVector containers") {
 }
 
 TEST_CASE("Compare array and fixed capacity container") {
-    std::array<int, 3> const arr{1, 2, 3};
-    std::array<int, 3> const arr2{1, 7, 3};
-    StaticVector<int, 7> const fcc{1, 2, 3};
+    std::array<int, 3> arr{1, 2, 3};
+    std::array<int, 3> arr2{1, 7, 3};
+    StaticVector<int, 7> fcc{1, 2, 3};
     REQUIRE(fcc == arr);
     REQUIRE(arr == fcc);
     REQUIRE_FALSE(fcc != arr);
@@ -41,9 +41,9 @@ TEST_CASE("Compare array and fixed capacity container") {
 }
 
 TEST_CASE("Compare vector and fixed capacity container") {
-    std::vector<int> const vec{1, 2, 3};
-    std::vector<int> const vec2{10, 2, 3};
-    StaticVector<int, 7> const fcc{1, 2, 3};
+    std::vector<int> vec{1, 2, 3};
+    std::vector<int> vec2{10, 2, 3};
+    StaticVector<int, 7> fcc{1, 2, 3};
     REQUIRE(fcc == vec);
     REQUIRE(vec == fcc);
     REQUIRE_FALSE(fcc != vec);
@@ -53,46 +53,46 @@ TEST_CASE("Compare vector and fixed capacity container") {
 }
 
 TEST_CASE("Construct from vector") {
-    std::vector<int> const vec{1, 2, 3};
-    StaticVector<int, 5> const fcc{vec};
+    std::vector<int> vec{1, 2, 3};
+    StaticVector<int, 5> fcc{vec};
     REQUIRE(fcc == vec);
 }
 
 TEST_CASE("Copy construct from vector") {
-    std::vector<int> const vec{1, 2, 3};
-    StaticVector<int, 5> const fcc = vec;
+    std::vector<int> vec{1, 2, 3};
+    StaticVector<int, 5> fcc = vec;
     REQUIRE(fcc == vec);
 }
 
 TEST_CASE("Copy assignment from vector") {
-    std::vector<int> const vec{1, 2, 3};
+    std::vector<int> vec{1, 2, 3};
     StaticVector<int, 5> fcc;
     fcc = vec;
     REQUIRE(fcc == vec);
 }
 
 TEST_CASE("Construct from array") {
-    std::array<int, 3> const arr{1, 2, 3};
-    StaticVector<int, 5> const fcc{arr};
+    std::array<int, 3> arr{1, 2, 3};
+    StaticVector<int, 5> fcc{arr};
     REQUIRE(fcc == arr);
 }
 
 TEST_CASE("Copy assign from array") {
-    std::array<int, 3> const arr{1, 2, 3};
+    std::array<int, 3> arr{1, 2, 3};
     StaticVector<int, 5> fcc;
     fcc = arr;
     REQUIRE(fcc == arr);
 }
 
 TEST_CASE("Copy construct from array") {
-    std::array<int, 3> const arr{1, 2, 3};
-    StaticVector<int, 5> const fcc = arr;
+    std::array<int, 3> arr{1, 2, 3};
+    StaticVector<int, 5> fcc = arr;
     REQUIRE(fcc == arr);
 }
 
 TEST_CASE("Construct from a smaller StaticVector") {
-    StaticVector<int, 3> const sv{1, 2, 3};
-    StaticVector<int, 5> const sv2{sv};
+    StaticVector<int, 3> sv{1, 2, 3};
+    StaticVector<int, 5> sv2{sv};
     REQUIRE(sv == sv2);
 }
 
@@ -183,7 +183,7 @@ SCENARIO("StaticVectors can be sized and resized", "[support]") {
     }
 
     GIVEN("An std::vector of size 3") {
-        std::vector<int> const standard_vector{5, 2, 1};
+        std::vector<int> standard_vector{5, 2, 1};
         WHEN("we construct a fixed capacity container from it") {
             StaticVector<int, 5> vec(standard_vector);
             THEN("size and data matches") {
@@ -202,7 +202,7 @@ SCENARIO("StaticVectors can be sized and resized", "[support]") {
 SCENARIO("Comparison of StaticVectors", "[support]") {
     GIVEN("Two containers containers that are equal at the start") {
         StaticVector<int, 5> a{0, 1, 2};
-        StaticVector<int, 5> const b{0, 1, 2};
+        StaticVector<int, 5> b{0, 1, 2};
         REQUIRE(a == b);
         REQUIRE_FALSE(a != b);
 
@@ -211,7 +211,7 @@ SCENARIO("Comparison of StaticVectors", "[support]") {
             THEN("they are not equal anymore") { REQUIRE(a != b); }
         }
         WHEN("Compared to a StaticVector with different capacity") {
-            StaticVector<int, 8> const c{0, 1, 2};
+            StaticVector<int, 8> c{0, 1, 2};
             THEN("The comparison still holds") {
                 REQUIRE(a == c);
                 REQUIRE_FALSE(a != c);
@@ -316,7 +316,7 @@ SCENARIO("Converting to vector", "[support]") {
     GIVEN("a StaticVector") {
         StaticVector<int, 5> a{1, 2, 3};
         WHEN("Converted into a vector") {
-            std::vector<int> const b(a);
+            std::vector<int> b(a);
             THEN("Data and size matches") {
                 REQUIRE(a == b);
                 REQUIRE(a.size() == b.size());

slsSupportLib/tests/test-ToString.cpp

@@ -59,7 +59,7 @@ TEST_CASE("conversion from duration to string", "[support]") {
 }
 
 TEST_CASE("Convert vector of time", "[support]") {
-    std::vector<ns> const vec{ns(150), us(10), ns(600)};
+    std::vector<ns> vec{ns(150), us(10), ns(600)};
     REQUIRE(ToString(vec) == "[150ns, 10us, 600ns]");
     REQUIRE(ToString(vec, "ns") == "[150ns, 10000ns, 600ns]");
 }
@@ -93,26 +93,26 @@ TEST_CASE("Vector of double", "[support]") {
 }
 
 TEST_CASE("Array") {
-    std::array<int, 3> const arr{1, 2, 3};
+    std::array<int, 3> arr{1, 2, 3};
     REQUIRE(ToString(arr) == "[1, 2, 3]");
 }
 
 TEST_CASE("Convert types with str method") {
-    IpAddr const addr;
+    IpAddr addr;
     REQUIRE(ToString(addr) == "0.0.0.0");
     REQUIRE(ToString(IpAddr{}) == "0.0.0.0");
 }
 
 TEST_CASE("String to string", "[support]") {
-    std::string const s = "hej";
+    std::string s = "hej";
     REQUIRE(ToString(s) == "hej");
 }
 
 TEST_CASE("vector of strings") {
-    std::vector<std::string> const vec{"5", "s"};
+    std::vector<std::string> vec{"5", "s"};
     REQUIRE(ToString(vec) == "[5, s]");
 
-    std::vector<std::string> const vec2{"some", "strange", "words", "75"};
+    std::vector<std::string> vec2{"some", "strange", "words", "75"};
     REQUIRE(ToString(vec2) == "[some, strange, words, 75]");
 }
 
@@ -150,7 +150,7 @@ TEST_CASE("string to detectorType") {
 
 TEST_CASE("vec") {
     using rs = slsDetectorDefs::runStatus;
-    std::vector<rs> const vec{rs::ERROR, rs::IDLE};
+    std::vector<rs> vec{rs::ERROR, rs::IDLE};
     REQUIRE(ToString(vec) == "[error, idle]");
 }
 
@@ -232,25 +232,25 @@ TEST_CASE("Detector type") {
 }
 
 TEST_CASE("Formatting slsDetectorDefs::ROI") {
-    slsDetectorDefs::ROI const roi(5, 159);
+    slsDetectorDefs::ROI roi(5, 159);
     REQUIRE(ToString(roi) == "[5, 159]");
-    slsDetectorDefs::ROI const roi1(5, 159, 6, 170);
+    slsDetectorDefs::ROI roi1(5, 159, 6, 170);
     REQUIRE(ToString(roi1) == "[5, 159, 6, 170]");
 }
 
 TEST_CASE("Streaming of slsDetectorDefs::ROI") {
     using namespace sls;
-    slsDetectorDefs::ROI const roi(-10, 1);
+    slsDetectorDefs::ROI roi(-10, 1);
     std::ostringstream oss, oss1;
     oss << roi;
     REQUIRE(oss.str() == "[-10, 1]");
-    slsDetectorDefs::ROI const roi1(-10, 1, 5, 11);
+    slsDetectorDefs::ROI roi1(-10, 1, 5, 11);
     oss1 << roi1;
     REQUIRE(oss1.str() == "[-10, 1, 5, 11]");
 }
 
 TEST_CASE("std::array") {
-    std::array<int, 3> const arr{4, 6, 7};
+    std::array<int, 3> arr{4, 6, 7};
     REQUIRE(ToString(arr) == "[4, 6, 7]");
 }
 
@@ -267,14 +267,14 @@ TEST_CASE("dac index to string") {
 }
 
 TEST_CASE("convert vector of strings to dac index") {
-    std::vector<std::string> const dacs{"vcassh", "vth2", "vrshaper"};
-    std::vector<defs::dacIndex> const daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
+    std::vector<std::string> dacs{"vcassh", "vth2", "vrshaper"};
+    std::vector<defs::dacIndex> daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
     auto r = StringTo<defs::dacIndex>(dacs);
     REQUIRE(r == daci);
 }
 
 TEST_CASE("vector of dac index to string") {
-    std::vector<defs::dacIndex> const daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
+    std::vector<defs::dacIndex> daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
     auto r = ToString(daci);
     REQUIRE(r == "[vcassh, vth2, vrshaper]");
 }
@@ -284,7 +284,7 @@ TEST_CASE("int or uin64_t to a string in hex") {
     REQUIRE(ToStringHex(65535, 8) == "0x0000ffff");
     REQUIRE(ToStringHex(8927748192) == "0x21422a060");
     REQUIRE(ToStringHex(8927748192, 16) == "0x000000021422a060");
-    std::vector<int> const temp{244, 65535, 1638582};
+    std::vector<int> temp{244, 65535, 1638582};
     auto r = ToStringHex(temp);
     REQUIRE(r == "[0xf4, 0xffff, 0x1900b6]");
     r = ToStringHex(temp, 8);
@@ -294,20 +294,20 @@ TEST_CASE("int or uin64_t to a string in hex") {
 TEST_CASE("Streaming of slsDetectorDefs::scanParameters") {
     using namespace sls;
     {
-        defs::scanParameters const t{};
+        defs::scanParameters t{};
         std::ostringstream oss;
         oss << t;
         REQUIRE(oss.str() == "[disabled]");
     }
     {
-        defs::scanParameters const t{defs::VTH2, 500, 1500, 500};
+        defs::scanParameters t{defs::VTH2, 500, 1500, 500};
         std::ostringstream oss;
         oss << t;
         REQUIRE(oss.str() == "[enabled\ndac vth2\nstart 500\nstop 1500\nstep "
                              "500\nsettleTime 1ms\n]");
     }
     {
-        defs::scanParameters const t{defs::VTH2, 500, 1500, 500,
+        defs::scanParameters t{defs::VTH2, 500, 1500, 500,
                                std::chrono::milliseconds{500}};
         std::ostringstream oss;
         oss << t;
@@ -317,17 +317,17 @@ TEST_CASE("Streaming of slsDetectorDefs::scanParameters") {
 }
 
 TEST_CASE("Printing c style arrays of int") {
-    int const arr[]{3, 5};
+    int arr[]{3, 5};
     REQUIRE(ToString(arr) == "[3, 5]");
 }
 
 TEST_CASE("Printing c style arrays of uint8") {
-    uint8_t const arr[]{1, 2, 3, 4, 5};
+    uint8_t arr[]{1, 2, 3, 4, 5};
     REQUIRE(ToString(arr) == "[1, 2, 3, 4, 5]");
 }
 
 TEST_CASE("Printing c style arrays of double") {
-    double const arr[]{3.4, 5.3, 6.2};
+    double arr[]{3.4, 5.3, 6.2};
     REQUIRE(ToString(arr) == "[3.4, 5.3, 6.2]");
 }