M3: fixed gain bits with negative polarity

* Setting pattern from memory (#218)

* ToString accepts c-style arrays

* fixed patwait time bug in validation

* Introduced pattern class

* compile for servers too

* Python binding for Pattern

* added scanParameters in Python

* slsReceiver: avoid potential memory leak around Implementation::generalData

* additional constructors for scanPrameters in python

* bugfix: avoid potentital memory leak in receiver if called outside constructor context

* added scanParameters in Python

* additional constructors for scanPrameters in python

* M3defaultpattern (#227)

* default pattern for m3 and moench including Python bindings

* M3settings (#228)

* some changes to compile on RH7 and in the server to load the default chip status register at startup

* Updated mythen3DeectorServer_developer executable with correct initialization at startup

Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com>
Co-authored-by: Anna Bergamaschi <anna.bergamaschi@psi.ch>

* Pattern.h as a public header files (#229)

* fixed buffer overflow but caused by using global instead of local enum

* replacing out of range trimbits with edge values

* replacing dac values that are out of range after interpolation

* updated pybind11 to 2.6.2

* Mythen3 improved synchronization (#231)

Disabling scans for multi module Mythen3, since there is no feedback of the detectors being ready
startDetector first starts the slaves then the master
acquire firs calls startDetector for the slaves then acquire on the master
getMaster to read back from hardware which one is master

* New server for JF to go with the new FW (#232)

* Modified Jungfrau speed settings for HW1.0 - FW fix version 1.1.1, compilation date 210218

* Corrected bug. DBIT clk phase is implemented in both HW version 1.0 and 2.0. Previous version did not update the DBIT phase shift on the configuration of a speed.

* fix for m3 scan with single module

* m3 fw version

* m3 server

* bugfix for bottom when setting quad

* new strategy for finding zmq based on cppzmq



Co-authored-by: Dhanya Thattil <dhanya.thattil@psi.ch>
Co-authored-by: Dhanya Thattil <33750417+thattil@users.noreply.github.com>
Co-authored-by: Alejandro Homs Puron <ahoms@esrf.fr>
Co-authored-by: Anna Bergamaschi <anna.bergamaschi@psi.ch>
Co-authored-by: Xiaoqiang Wang <xiaoqiangwang@gmail.com>
Co-authored-by: lopez_c <carlos.lopez-cuenca@psi.ch>

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.12)
 project(slsDetectorPackage)
-set(PROJECT_VERSION 5.0.0)
+set(PROJECT_VERSION 5.1.0)
 include(CheckIPOSupported)
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 
@@ -157,8 +157,37 @@ set(CMAKE_INSTALL_RPATH $ORIGIN)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
 
 
+set(ZeroMQ_HINT "" CACHE STRING "Hint where ZeroMQ could be found")
+#Adapted from: https://github.com/zeromq/cppzmq/
+if (NOT TARGET libzmq)
+    if(ZeroMQ_HINT)
+        message(STATUS "Looking for ZeroMQ in: ${ZeroMQ_HINT}")
+        find_package(ZeroMQ 4 
+            NO_DEFAULT_PATH
+            HINTS ${ZeroMQ_DIR}
+        )
+    else()
+        find_package(ZeroMQ 4 QUIET)
+    endif()
+    
 
-find_package(ZeroMQ 4 REQUIRED)
+
+  # libzmq autotools install: fallback to pkg-config
+  if(NOT ZeroMQ_FOUND)
+    message(STATUS "CMake libzmq package not found, trying again with pkg-config (normal install of zeromq)")
+    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
+    find_package(ZeroMQ 4 REQUIRED)
+  endif()
+
+  # TODO "REQUIRED" above should already cause a fatal failure if not found, but this doesn't seem to work
+  if(NOT ZeroMQ_FOUND)
+    message(FATAL_ERROR "ZeroMQ was not found, neither as a CMake package nor via pkg-config")
+  endif()
+
+  if (ZeroMQ_FOUND AND NOT TARGET libzmq)
+    message(FATAL_ERROR "ZeroMQ version not supported!")
+  endif()
+endif()
 
 if (SLS_USE_TESTS)
     enable_testing()

RELEASE.txt

@@ -1,14 +1,13 @@
-SLS Detector Package 5.1.0 released on xx.xx.2020 (Minor Release)
+SLS Detector Package 5.X.X released on XX.XX.2021 (Minor Release)
 ===================================================================
 
-This document describes the differences between 5.1.0 and 5.x.x releases.   
+This document describes the differences between X and Y releases.   
 
 
 
     CONTENTS
     --------
-    1.  Topics Concerning
+    1.  New Features
-    2.  New Features
     2.  Resolved Issues
     3.  Known Issues
     4.  Firmware Requirements
@@ -16,50 +15,15 @@ This document describes the differences between 5.1.0 and 5.x.x releases.
 
 
 
-1. Topics Concerning
-====================
 
-    - potentital memory leak in receiver
+1. New Features
-    - scanParameters in Python
-    - cmk.sh refactored
-    - m3 settings and threshold
-
-
-2. New Features
 ===============
 
-    Client
+    Setting Mythen3 gain from command line
-    ------
-
-    1. Aded settings and threshold features for Mythen3.
-    
-
-3. Resolved Issues
-==================
-
-
-    Receiver
-    --------
-
-    1.  Current code only calls Implementation::setDetectorType from constructor, 
-	    but potential memory leak if called out of constructor context. Fixed.
-
-    Client
-    ------
-
-    1.  Fixed missing scanParameters class in Python 
-
-    2.  cmk.sh refactored to have better option handling
-
-
-
-
 
 4. Firmware Requirements
 ========================
-        
+    
-    No updates from 5.0.0
-
 
 
 5. Known Issues

cmake/FindZeroMQ.cmake

@@ -1,112 +0,0 @@
-
-# This file is originally from https://github.com/zeromq/azmq and distributed 
-# under Boost Software Lincese 1.0
-# Boost Software License - Version 1.0 - August 17th, 2003
-
-# Permission is hereby granted, free of charge, to any person or organization
-# obtaining a copy of the software and accompanying documentation covered by
-# this license (the "Software") to use, reproduce, display, distribute,
-# execute, and transmit the Software, and to prepare derivative works of the
-# Software, and to permit third-parties to whom the Software is furnished to
-# do so, all subject to the following:
-
-# The copyright notices in the Software and this entire statement, including
-# the above license grant, this restriction and the following disclaimer,
-# must be included in all copies of the Software, in whole or in part, and
-# all derivative works of the Software, unless such copies or derivative
-# works are solely in the form of machine-executable object code generated by
-# a source language processor.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-# SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-# FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-# --------------------------------------------------------------------------------
-
-# Find ZeroMQ Headers/Libs
-
-# Variables
-# ZMQ_ROOT - set this to a location where ZeroMQ may be found
-#
-# ZeroMQ_FOUND - True of ZeroMQ found
-# ZeroMQ_INCLUDE_DIRS - Location of ZeroMQ includes
-# ZeroMQ_LIBRARIES - ZeroMQ libraries
-
-include(FindPackageHandleStandardArgs)
-
-if (NOT ZMQ_ROOT)
-    set(ZMQ_ROOT "$ENV{ZMQ_ROOT}")
-endif()
-
-if (NOT ZMQ_ROOT)
-    find_path(_ZeroMQ_ROOT NAMES include/zmq.h)
-else()
-    set(_ZeroMQ_ROOT "${ZMQ_ROOT}")
-endif()
-
-find_path(ZeroMQ_INCLUDE_DIRS NAMES zmq.h HINTS ${_ZeroMQ_ROOT}/include)
-
-if (ZeroMQ_INCLUDE_DIRS)
-    set(_ZeroMQ_H ${ZeroMQ_INCLUDE_DIRS}/zmq.h)
-
-    function(_zmqver_EXTRACT _ZeroMQ_VER_COMPONENT _ZeroMQ_VER_OUTPUT)
-        set(CMAKE_MATCH_1 "0")
-        set(_ZeroMQ_expr "^[ \\t]*#define[ \\t]+${_ZeroMQ_VER_COMPONENT}[ \\t]+([0-9]+)$")
-        file(STRINGS "${_ZeroMQ_H}" _ZeroMQ_ver REGEX "${_ZeroMQ_expr}")
-        string(REGEX MATCH "${_ZeroMQ_expr}" ZeroMQ_ver "${_ZeroMQ_ver}")
-        set(${_ZeroMQ_VER_OUTPUT} "${CMAKE_MATCH_1}" PARENT_SCOPE)
-    endfunction()
-
-    _zmqver_EXTRACT("ZMQ_VERSION_MAJOR" ZeroMQ_VERSION_MAJOR)
-    _zmqver_EXTRACT("ZMQ_VERSION_MINOR" ZeroMQ_VERSION_MINOR)
-    _zmqver_EXTRACT("ZMQ_VERSION_PATCH" ZeroMQ_VERSION_PATCH)
-
-    message(STATUS "ZeroMQ version: ${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}.${ZeroMQ_VERSION_PATCH}")
-
-    # We should provide version to find_package_handle_standard_args in the same format as it was requested,
-    # otherwise it can't check whether version matches exactly.
-    if (ZeroMQ_FIND_VERSION_COUNT GREATER 2)
-        set(ZeroMQ_VERSION "${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}.${ZeroMQ_VERSION_PATCH}")
-    else()
-        # User has requested ZeroMQ version without patch part => user is not interested in specific patch =>
-        # any patch should be an exact match.
-        set(ZeroMQ_VERSION "${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}")
-    endif()
-
-    if (NOT ${CMAKE_CXX_PLATFORM_ID} STREQUAL "Windows")
-        find_library(ZeroMQ_LIBRARIES NAMES zmq HINTS ${_ZeroMQ_ROOT}/lib)
-    else()
-        find_library(
-            ZeroMQ_LIBRARY_RELEASE
-            NAMES
-                libzmq
-                "libzmq-${CMAKE_VS_PLATFORM_TOOLSET}-mt-${ZeroMQ_VERSION_MAJOR}_${ZeroMQ_VERSION_MINOR}_${ZeroMQ_VERSION_PATCH}"
-            HINTS
-                ${_ZeroMQ_ROOT}/lib
-            )
-
-        find_library(
-            ZeroMQ_LIBRARY_DEBUG
-            NAMES
-                libzmq_d
-                "libzmq-${CMAKE_VS_PLATFORM_TOOLSET}-mt-gd-${ZeroMQ_VERSION_MAJOR}_${ZeroMQ_VERSION_MINOR}_${ZeroMQ_VERSION_PATCH}"
-            HINTS
-                ${_ZeroMQ_ROOT}/lib)
-
-        # On Windows we have to use corresponding version (i.e. Release or Debug) of ZeroMQ because of `errno` CRT global variable
-        # See more at http://www.drdobbs.com/avoiding-the-visual-c-runtime-library/184416623
-        set(ZeroMQ_LIBRARIES optimized "${ZeroMQ_LIBRARY_RELEASE}" debug "${ZeroMQ_LIBRARY_DEBUG}")
-    endif()
-endif()
-
-find_package_handle_standard_args(ZeroMQ FOUND_VAR ZeroMQ_FOUND
-    REQUIRED_VARS ZeroMQ_INCLUDE_DIRS ZeroMQ_LIBRARIES
-    VERSION_VAR ZeroMQ_VERSION)
-
-if (ZeroMQ_FOUND)
-    mark_as_advanced(ZeroMQ_INCLUDE_DIRS ZeroMQ_LIBRARIES ZeroMQ_VERSION
-        ZeroMQ_VERSION_MAJOR ZeroMQ_VERSION_MINOR ZeroMQ_VERSION_PATCH)
-endif()

cmake/package_config.cmake

@@ -25,6 +25,12 @@ install(FILES
   DESTINATION ${CMAKE_INSTALL_DIR}
 )
 
+install(FILES
+  "${CMAKE_SOURCE_DIR}/libzmq-pkg-config/FindZeroMQ.cmake"
+  COMPONENT devel
+  DESTINATION ${CMAKE_INSTALL_DIR}/libzmq-pkg-config
+)
+
 if (PROJECT_LIBRARIES OR PROJECT_STATIC_LIBRARIES)
   install(
     EXPORT "${TARGETS_EXPORT_NAME}"

cmake/project-config.cmake.in

@@ -12,8 +12,21 @@ include(CMakeFindDependencyMacro)
 
 set(SLS_USE_HDF5 "@SLS_USE_HDF5@")
 
-# Add optional dependencies here
+
+find_package(ZeroMQ 4 QUIET)
+# libzmq autotools install: fallback to pkg-config
+if(NOT ZeroMQ_FOUND)
+    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
+    find_package(ZeroMQ 4 REQUIRED)
+endif()
+
+if(NOT ZeroMQ_FOUND)
+    message(FATAL_ERROR "ZeroMQ was NOT found!")
+endif()
+
 find_dependency(Threads)
+
+# Add optional dependencies here
 if (SLS_USE_HDF5)
     find_dependency(HDF5)
 endif ()

conda-recepie/build.sh

@@ -13,8 +13,9 @@ cmake .. \
       -DCMAKE_BUILD_TYPE=Release \
       -DSLS_USE_HDF5=OFF\
      
-
+NCORES=$(getconf _NPROCESSORS_ONLN)
-cmake --build . -- -j10
+echo "Building using: ${NCORES} cores"
+cmake --build . -- -j${NCORES}
 cmake --build . --target install
 
-CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
+CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2

conda-recepie/copy_gui.sh

@@ -1,3 +1,3 @@
 #Copy the GUI 
-mkdir $PREFIX/bin
+mkdir -p $PREFIX/bin
-cp build/bin/slsDetectorGui $PREFIX/bin/.
+cp build/install/bin/slsDetectorGui $PREFIX/bin/.

conda-recepie/copy_lib.sh

@@ -1,6 +1,6 @@
 
-mkdir $PREFIX/lib
+mkdir -p $PREFIX/lib
-mkdir $PREFIX/bin
+mkdir -p $PREFIX/bin
 mkdir -p $PREFIX/include/sls
 # mkdir $PREFIX/include/slsDetectorPackage
 

conda-recepie/meta.yaml

@@ -59,6 +59,16 @@ outputs:
     script: copy_lib.sh
 
     requirements:
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - libstdcxx-ng
+        - libgcc-ng
+        - zeromq
+
+      host:
+        - zeromq
+
       run: 
         - libstdcxx-ng
         - libgcc-ng
@@ -78,6 +88,8 @@ outputs:
 
       host:
         - python
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+
 
       run:
         - libstdcxx-ng
@@ -94,6 +106,13 @@ outputs:
   - name: slsdetgui
     script: copy_gui.sh
     requirements:
+
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+        - qwt 6.*
+
       run:
         - {{ pin_subpackage('slsdetlib', exact=True) }}
         - qwt 6.*

libzmq-pkg-config/FindZeroMQ.cmake

@@ -0,0 +1,27 @@
+#From: https://github.com/zeromq/cppzmq/
+set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON)
+find_package(PkgConfig)
+pkg_check_modules(PC_LIBZMQ QUIET libzmq)
+
+set(ZeroMQ_VERSION ${PC_LIBZMQ_VERSION})
+find_library(ZeroMQ_LIBRARY NAMES libzmq.so libzmq.dylib libzmq.dll
+             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
+find_library(ZeroMQ_STATIC_LIBRARY NAMES libzmq-static.a libzmq.a libzmq.dll.a
+             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
+
+if(ZeroMQ_LIBRARY OR ZeroMQ_STATIC_LIBRARY)
+    set(ZeroMQ_FOUND ON)
+endif()
+
+if (TARGET libzmq)
+    # avoid errors defining targets twice
+    return()
+endif()
+
+add_library(libzmq SHARED IMPORTED)
+set_property(TARGET libzmq PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
+set_property(TARGET libzmq PROPERTY IMPORTED_LOCATION ${ZeroMQ_LIBRARY})
+
+add_library(libzmq-static STATIC IMPORTED ${PC_LIBZMQ_INCLUDE_DIRS})
+set_property(TARGET libzmq-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
+set_property(TARGET libzmq-static PROPERTY IMPORTED_LOCATION ${ZeroMQ_STATIC_LIBRARY})

python/scripts/compile_servers.py

@@ -0,0 +1,80 @@
+import subprocess
+import os
+import sys
+from pathlib import Path
+import shutil as sh
+from argparse import ArgumentParser
+
+class color:
+    HEADER = "\033[95m"
+    BLUE = "\033[94m"
+    CYAN = "\033[96m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    RED = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    MAGENTA = "\033[35m"
+
+    @staticmethod
+    def red(s):
+        return f"{color.RED}{s}{color.ENDC}"
+
+    @staticmethod
+    def green(s):
+        return f"{color.GREEN}{s}{color.ENDC}"
+
+def add_to_path():
+    paths = [
+        "/opt/uClinux/bfin-uclinux/bin",
+        "/opt/nios2-gcc/bin",
+        "/opt/eldk-5.1/powerpc-4xx-softfloat/sysroots/i686-eldk-linux/usr/bin/ppc405-linux",
+    ]
+    os.environ["PATH"] += os.pathsep + os.pathsep.join(paths)
+
+
+def rc_to_string(rc):
+    if rc == 0:
+        return color.green("OK")
+    else:
+        return color.red("FAIL")
+
+
+
+parser = ArgumentParser()
+parser.add_argument('-t', '--tag', help = 'Tag added to server file name', default='developer')
+parser.add_argument('-g', '--git', help='Add new servers to the git repo', action="store_true")
+args = parser.parse_args()
+
+
+servers = [
+#     "eigerDetectorServer",
+#     "jungfrauDetectorServer",
+      "mythen3DetectorServer",
+#     "gotthard2DetectorServer",
+#     "gotthardDetectorServer",
+#     "ctbDetectorServer",
+#     "moenchDetectorServer",
+]
+
+
+server_root = Path("../../slsDetectorServers/").resolve()
+
+add_to_path()
+for server in servers:
+    bin_name = f"{server}_{args.tag}"
+    path = server_root / server
+    print(f"{bin_name} - ", end="")
+    os.chdir(path)
+    try: 
+        sh.rmtree(path/'bin')
+    except FileNotFoundError:
+        pass
+    p = subprocess.run(["make"], stdout=subprocess.DEVNULL)
+    print(rc_to_string(p.returncode))
+    if p.returncode == 0:
+        sh.move(f"bin/{server}", f"bin/{bin_name}")
+        if args.git:
+            print("Adding to git")
+            subprocess.run(['git', 'add', 'bin', '-f'])

python/scripts/generate_enums.py

@@ -11,6 +11,8 @@ import subprocess
 
 from parse import remove_comments
 
+allow_bitwise_op = ["M3_GainCaps"]
+
 def single_line_enum(line):
     sub = line[line.find('{')+1:line.find('}')]
     return sub.strip().split(',')
@@ -49,7 +51,11 @@ def extract_enums(lines):
 def generate_enum_string(enums):
     data = []
     for key, value in enums.items():
-        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
+        if key in allow_bitwise_op:
+            tag=", py::arithmetic()"
+        else:
+            tag=""
+        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}"{tag})\n')
         for v in value:
             data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
         data.append('.export_values();\n\n')

python/setup.py

@@ -2,11 +2,12 @@
 Setup file for slsdet
 Build upon the pybind11 example found here: https://github.com/pybind/python_example
 """
-from setuptools import setup, Extension, find_packages
+
-from setuptools.command.build_ext import build_ext
-import sys
-import setuptools
 import os
+import sys
+sys.path.append('../libs/pybind11')
+from setuptools import setup, find_packages
+from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 __version__ = os.environ.get('GIT_DESCRIBE_TAG', 'developer')
 
@@ -19,109 +20,29 @@ def get_conda_path():
     return os.environ['CONDA_PREFIX']
 
 
-# class get_pybind_include(object):
+#TODO migrate to CMake build? 
-#     """Helper class to determine the pybind11 include path
-#     The purpose of this class is to postpone importing pybind11
-#     until it is actually installed, so that the ``get_include()``
-#     method can be invoked. """
-
-#     def __init__(self, user=False):
-#         self.user = user
-
-#     def __str__(self):
-#         import pybind11
-#         return pybind11.get_include(self.user)
-
-
 ext_modules = [
-    Extension(
+    Pybind11Extension(
         '_slsdet',
         ['src/main.cpp',
         'src/enums.cpp',
         'src/detector.cpp',
-        'src/network.cpp'],
+        'src/network.cpp',
+        'src/pattern.cpp',
+        'src/scan.cpp',],
         include_dirs=[
-            # Path to pybind11 headers
-            # get_pybind_include(),
-            # get_pybind_include(user=True),
             os.path.join('../libs/pybind11/include'),
             os.path.join(get_conda_path(), 'include'),
 
         ],
-        libraries=['SlsDetector', 'SlsReceiver', 'zmq'],
+        libraries=['SlsDetector', 'SlsSupport', 'SlsReceiver', 'zmq'],
         library_dirs=[
             os.path.join(get_conda_path(), 'lib'),
-            os.path.join(get_conda_path(), 'bin'),
         ],
-
         language='c++'
     ),
 ]
 
-
-# As of Python 3.6, CCompiler has a `has_flag` method.
-# cf http://bugs.python.org/issue26689
-def has_flag(compiler, flagname):
-    """Return a boolean indicating whether a flag name is supported on
-    the specified compiler.
-    """
-    import tempfile
-    with tempfile.NamedTemporaryFile('w', suffix='.cpp') as f:
-        f.write('int main (int argc, char **argv) { return 0; }')
-        try:
-            compiler.compile([f.name], extra_postargs=[flagname])
-        except setuptools.distutils.errors.CompileError:
-            return False
-    return True
-
-
-def cpp_flag(compiler):
-    """Return the -std=c++[11/14] compiler flag.
-    The c++14 is prefered over c++11 (when it is available).
-    """
-    if has_flag(compiler, '-std=c++14'):
-        return '-std=c++14'
-    elif has_flag(compiler, '-std=c++11'):
-        return '-std=c++11'
-    else:
-        raise RuntimeError('Unsupported compiler -- at least C++11 support '
-                           'is needed!')
-
-
-class BuildExt(build_ext):
-    """A custom build extension for adding compiler-specific options."""
-    c_opts = {
-        'msvc': ['/EHsc'],
-        'unix': [],
-    }
-
-    if sys.platform == 'darwin':
-        c_opts['unix'] += ['-stdlib=libc++', '-mmacosx-version-min=10.7']
-
-    def build_extensions(self):
-        ct = self.compiler.compiler_type
-        opts = self.c_opts.get(ct, [])
-        if ct == 'unix':
-            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
-            opts.append(cpp_flag(self.compiler))
-            if has_flag(self.compiler, '-fvisibility=hidden'):
-                opts.append('-fvisibility=hidden')
-        elif ct == 'msvc':
-            opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())
-        for ext in self.extensions:
-            ext.extra_compile_args = opts
-
-        print('**************************************************')
-        print(ct)
-        print(opts)
-        print('**************************************************')
-        build_ext.build_extensions(self)
-        
-
-
-def get_shared_lib():
-    return [f for f in os.listdir('.') if '_slsdet' in f]
-
 setup(
     name='slsdet',
     version=__version__,
@@ -132,6 +53,6 @@ setup(
     long_description='',
     packages=find_packages(exclude=['contrib', 'docs', 'tests']),
     ext_modules=ext_modules,
-    cmdclass={'build_ext': BuildExt},
+    cmdclass={"build_ext": build_ext},
     zip_safe=False,
 )

python/slsdet/enums.py

@@ -14,4 +14,5 @@ clockIndex = _slsdet.slsDetectorDefs.clockIndex
 readoutMode = _slsdet.slsDetectorDefs.readoutMode
 masterFlags = _slsdet.slsDetectorDefs.masterFlags
 burstMode = _slsdet.slsDetectorDefs.burstMode
-timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+M3_GainCaps = _slsdet.slsDetectorDefs.M3_GainCaps

python/src/detector.cpp

@@ -1132,6 +1132,20 @@ void init_det(py::module &m) {
              (Result<std::array<ns, 3>>(Detector::*)(sls::Positions) const) &
                  Detector::getGateDelayForAllGates,
              py::arg() = Positions{})
+        .def("getMaster",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getMaster,
+             py::arg() = Positions{})
+        .def("getChipStatusRegister",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getChipStatusRegister,
+             py::arg() = Positions{})
+        .def("setGainCaps",
+             (void (Detector::*)(int, sls::Positions)) & Detector::setGainCaps,
+             py::arg(), py::arg() = Positions{})
+        .def("getGainCaps",
+             (Result<int>(Detector::*)(sls::Positions)) & Detector::getGainCaps,
+             py::arg() = Positions{})
         .def("getNumberOfAnalogSamples",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getNumberOfAnalogSamples,

python/src/enums.cpp

@@ -277,4 +277,14 @@ void init_enums(py::module &m) {
         .value("TIMING_EXTERNAL",
                slsDetectorDefs::timingSourceType::TIMING_EXTERNAL)
         .export_values();
+
+    py::enum_<slsDetectorDefs::M3_GainCaps>(Defs, "M3_GainCaps",
+                                            py::arithmetic())
+        .value("M3_C10pre", slsDetectorDefs::M3_GainCaps::M3_C10pre)
+        .value("M3_C15sh", slsDetectorDefs::M3_GainCaps::M3_C15sh)
+        .value("M3_C30sh", slsDetectorDefs::M3_GainCaps::M3_C30sh)
+        .value("M3_C50sh", slsDetectorDefs::M3_GainCaps::M3_C50sh)
+        .value("M3_C225ACsh", slsDetectorDefs::M3_GainCaps::M3_C225ACsh)
+        .value("M3_C15pre", slsDetectorDefs::M3_GainCaps::M3_C15pre)
+        .export_values();
 }

slsDetectorGui/CMakeLists.txt

@@ -91,7 +91,6 @@ target_include_directories(slsDetectorGui PUBLIC
 
 target_link_libraries(slsDetectorGui PUBLIC
     slsProjectOptions 
-    slsProjectWarnings
     slsDetectorStatic
     ${QT_QTCORE_LIBRARIES}
     ${QT_QTGUI_LIBRARIES}
@@ -101,6 +100,9 @@ target_link_libraries(slsDetectorGui PUBLIC
     Qt4::QtOpenGL
     Qt4::QtSvg
     expat
+    
+    PRIVATE
+    slsProjectWarnings
 )
 
 set_target_properties(slsDetectorGui PROPERTIES
@@ -111,7 +113,7 @@ if(SLS_LTO_AVAILABLE)
 endif()
 
 install(TARGETS slsDetectorGui
-    EXPORT "${TARGETS_EXPORT_NAME}"
+    # EXPORT "${TARGETS_EXPORT_NAME}" #do not export gui
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}

slsDetectorServers/eigerDetectorServer/FebControl.c

@@ -1395,7 +1395,7 @@ int Feb_Control_SetMaster(enum MASTERINDEX ind) {
 int Feb_Control_SetQuad(int val) {
     LOG(logINFO, ("Setting Quad to %d in Feb\n", val));
     // only setting on the right feb if quad
-    return Feb_Control_SetTop(val == 0 ? TOP_HARDWARE : OW_TOP, 0, 1);
+    return Feb_Control_SetTop(val == 0 ? TOP_HARDWARE : OW_BOTTOM, 0, 1);
 }
 
 int Feb_Control_SetReadNLines(int value) {

slsDetectorServers/eigerDetectorServer/bin/config_eiger.txt

@@ -0,0 +1,2 @@
+top 1
+master 1

slsDetectorServers/gotthard2DetectorServer/bin/config_gotthard2.txt

@@ -0,0 +1,33 @@
+
+
+#onchip dacs        chip index   value (max 0x3ff)
+vchip_comp_fe       -1          0x137
+vchip_opa_1st       -1          0x000
+vchip_opa_fd        -1          0x134
+vchip_comp_adc      -1          0x3FF   
+vchip_ref_comp_fe   -1          0x180
+vchip_cs            -1          0x0D0
+
+#dacs           value (max 4096)
+vref_h_adc      2116
+vb_comp_fe      0
+vb_comp_adc     0
+vcom_cds        705
+vref_rstore     150
+vb_opa_1st      0
+vref_comp_fe    0
+vcom_adc1       705
+vref_prech      869
+vref_l_adc      700
+vref_cds        700
+vb_cs           2799
+vb_opa_fd       0
+vcom_adc2       704
+
+#configure adc  chip index      adc index   value(max 0x7F)
+confadc         -1              -1          0x22
+
+#vetoreference  gain index  value(max 4095)
+vetoref         1           0
+
+

slsDetectorServers/gotthardDetectorServer/bin/config_gotthard.txt

@@ -0,0 +1,23 @@
+#masterflags (no_master, is_master, is_slave)
+masterflags no_master
+
+#master default delay 
+masterdefaultdelay 70
+
+#patternphase 
+patternphase 0
+
+#adcphase 
+adcphase 0
+
+#slave pattern phase
+slavepatternphase 0
+
+#slave adc phase 
+slaveadcphase 0
+
+#rst to sw1 delay
+rsttosw1delay 2
+
+#start acquisition delay
+startacqdelay 1

slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c

@@ -1396,11 +1396,8 @@ int setClockDivider(enum CLKINDEX ind, int val) {
     setPhase(ADC_CLK, adcPhase, 0);
     LOG(logINFO, ("\tSet ADC Phase Reg to %d\n", adcPhase));
 
-    // only implemented in the new boards now
+    setPhase(DBIT_CLK, dbitPhase, 0);
-    if (!isHardwareVersion2()) {
+    LOG(logINFO, ("\tSet DBIT Phase Reg to %d\n", dbitPhase));
-        setPhase(DBIT_CLK, dbitPhase, 0);
-        LOG(logINFO, ("\tSet DBIT Phase Reg to %d\n", dbitPhase));
-    }
 
     return OK;
 }

slsDetectorServers/jungfrauDetectorServer/slsDetectorServer_defs.h

@@ -3,7 +3,7 @@
 #include "sls/sls_detector_defs.h"
 
 #define MIN_REQRD_VRSN_T_RD_API  0x171220
-#define REQRD_FRMWRE_VRSN_BOARD2 0x200724 // 1.0 pcb
+#define REQRD_FRMWRE_VRSN_BOARD2 0x210218 // 1.0 pcb
 #define REQRD_FRMWRE_VRSN        0x200721 // 2.0 pcb
 
 #define CTRL_SRVR_INIT_TIME_US (300 * 1000)
@@ -113,8 +113,8 @@ enum CLKINDEX { RUN_CLK, ADC_CLK, DBIT_CLK, NUM_CLOCKS };
 #define ADC_OFST_FULL_SPEED_VAL           (0x10) // 2.0 pcb
 #define ADC_OFST_HALF_SPEED_VAL           (0x08) // 2.0 pcb
 #define ADC_OFST_QUARTER_SPEED_VAL        (0x04) // 2.0 pcb
-#define ADC_OFST_HALF_SPEED_BOARD2_VAL    (0x13) // 1.0 pcb (2 resistor network)
+#define ADC_OFST_HALF_SPEED_BOARD2_VAL    (0x10) // 1.0 pcb (2 resistor network)
-#define ADC_OFST_QUARTER_SPEED_BOARD2_VAL (0x0b) // 1.0 pcb (2 resistor network)
+#define ADC_OFST_QUARTER_SPEED_BOARD2_VAL (0x08) // 1.0 pcb (2 resistor network)
 
 #define ADC_PORT_INVERT_VAL        (0x5A5A5A5A)
 #define ADC_PORT_INVERT_BOARD2_VAL (0x453b2a9c)
@@ -140,8 +140,8 @@ enum CLKINDEX { RUN_CLK, ADC_CLK, DBIT_CLK, NUM_CLOCKS };
 #define ADC_PHASE_FULL_SPEED           (150) // 2.0 pcb
 #define ADC_PHASE_HALF_SPEED           (200) // 2.0 pcb
 #define ADC_PHASE_QUARTER_SPEED        (200) // 2.0 pcb
-#define ADC_PHASE_HALF_SPEED_BOARD2    (75)  // 1.0 pcb (2 resistor network)
+#define ADC_PHASE_HALF_SPEED_BOARD2    (110)  // 1.0 pcb (2 resistor network)
-#define ADC_PHASE_QUARTER_SPEED_BOARD2 (75)  // 1.0 pcb (2 resistor network)
+#define ADC_PHASE_QUARTER_SPEED_BOARD2 (220)  // 1.0 pcb (2 resistor network)
 
 #define DBIT_PHASE_FULL_SPEED           (85)  // 2.0 pcb
 #define DBIT_PHASE_HALF_SPEED           (150) // 2.0 pcb

slsDetectorServers/moenchDetectorServer/bin/DefaultPattern_moench.txt

@@ -0,0 +1,288 @@
+patword 0x0000 0x0008599f0418503a
+patword 0x0001 0x0008599f0418503a
+patword 0x0002 0x000859960418503a
+patword 0x0003 0x000859960418503a
+patword 0x0004 0x000859960418503a
+patword 0x0005 0x000859960418503a
+patword 0x0006 0x000859960418503a
+patword 0x0007 0x000859960418503a
+patword 0x0008 0x000859960418503a
+patword 0x0009 0x000859960418503a
+patword 0x000a 0x000859960418503a
+patword 0x000b 0x000859960418503a
+patword 0x000c 0x000859960418503a
+patword 0x000d 0x000859960418503a
+patword 0x000e 0x000859960418503a
+patword 0x000f 0x000859960418503a
+patword 0x0010 0x000859960418503a
+patword 0x0011 0x000859960418503a
+patword 0x0012 0x000859960418503a
+patword 0x0013 0x000859960418503a
+patword 0x0014 0x000859960418503a
+patword 0x0015 0x000859960418503a
+patword 0x0016 0x000819960418501a
+patword 0x0017 0x000819960418501a
+patword 0x0018 0x000819960418501a
+patword 0x0019 0x000819960418501a
+patword 0x001a 0x000819960418501a
+patword 0x001b 0x000819960418501a
+patword 0x001c 0x000819960418501a
+patword 0x001d 0x000819960418501a
+patword 0x001e 0x000819960418501a
+patword 0x001f 0x000819960418501a
+patword 0x0020 0x000819960418501a
+patword 0x0021 0x000819960418501a
+patword 0x0022 0x000819960418501a
+patword 0x0023 0x000819960418501a
+patword 0x0024 0x000819960418501a
+patword 0x0025 0x000819960418501a
+patword 0x0026 0x000819960418501a
+patword 0x0027 0x000819960418501a
+patword 0x0028 0x000819960418501a
+patword 0x0029 0x000819960418501a
+patword 0x002a 0x000819960418501a
+patword 0x002b 0x000819960418501a
+patword 0x002c 0x000819960418501a
+patword 0x002d 0x000819960418501a
+patword 0x002e 0x000819960418501a
+patword 0x002f 0x000819960418501a
+patword 0x0030 0x000819960008501a
+patword 0x0031 0x000819960008501a
+patword 0x0032 0x000819960008501a
+patword 0x0033 0x000819960008501a
+patword 0x0034 0x000819960008501a
+patword 0x0035 0x000819960008501a
+patword 0x0036 0x000819960008501a
+patword 0x0037 0x000819960008501a
+patword 0x0038 0x000819960008501a
+patword 0x0039 0x000819960008501a
+patword 0x003a 0x000819960008501a
+patword 0x003b 0x000819960008501a
+patword 0x003c 0x000819960008501a
+patword 0x003d 0x000819960008501a
+patword 0x003e 0x000819960008501a
+patword 0x003f 0x000819960008501a
+patword 0x0040 0x000819960008501a
+patword 0x0041 0x000819960008501a
+patword 0x0042 0x000819960008501a
+patword 0x0043 0x000819960008501a
+patword 0x0044 0x0008199f0008501a
+patword 0x0045 0x0008199f0008501a
+patword 0x0046 0x0008199f0008501a
+patword 0x0047 0x0008199f0008501a
+patword 0x0048 0x0008199f0008501a
+patword 0x0049 0x0008199f0008501a
+patword 0x004a 0x0008199f0008501a
+patword 0x004b 0x0008199f0008501a
+patword 0x004c 0x0008199f0008501a
+patword 0x004d 0x0008199f0008501a
+patword 0x004e 0x0008199f0008501a
+patword 0x004f 0x0008199f0008501a
+patword 0x0050 0x0008199f0008501a
+patword 0x0051 0x0008199f0008501a
+patword 0x0052 0x0008199f0008501a
+patword 0x0053 0x0008199f0008501a
+patword 0x0054 0x0008199f0008501a
+patword 0x0055 0x0008199f0008501a
+patword 0x0056 0x0008199f0008501a
+patword 0x0057 0x0008199f0008501a
+patword 0x0058 0x0008599f0008503a
+patword 0x0059 0x0008599f0008503a
+patword 0x005a 0x000c599f000850ba
+patword 0x005b 0x000c599f000850ba
+patword 0x005c 0x000c599f000850ba
+patword 0x005d 0x000c599f000850ba
+patword 0x005e 0x000c599f000850ba
+patword 0x005f 0x000c599f000850ba
+patword 0x0060 0x000c599f000850ba
+patword 0x0061 0x000c599f000850ba
+patword 0x0062 0x000c599f000850ba
+patword 0x0063 0x000c599f000850ba
+patword 0x0064 0x000c599f000850ba
+patword 0x0065 0x000c599f000850ba
+patword 0x0066 0x000c599f000850ba
+patword 0x0067 0x000c599f000850ba
+patword 0x0068 0x000c599f000850ba
+patword 0x0069 0x000c599f000850ba
+patword 0x006a 0x000c599f000850ba
+patword 0x006b 0x000c599f000850ba
+patword 0x006c 0x000c599f000850ba
+patword 0x006d 0x000c599f000850ba
+patword 0x006e 0x000c799f010858ba
+patword 0x006f 0x000c799f010858ba
+patword 0x0070 0x000c599f000850ba
+patword 0x0071 0x000c599f000850ba
+patword 0x0072 0x000c599f000850ba
+patword 0x0073 0x000c599f000850ba
+patword 0x0074 0x000c599f000850ba
+patword 0x0075 0x000c599f000850ba
+patword 0x0076 0x000c599f000850ba
+patword 0x0077 0x000c599f000850ba
+patword 0x0078 0x000c599f000850ba
+patword 0x0079 0x000c599f000850ba
+patword 0x007a 0x000c599f000850ba
+patword 0x007b 0x000c599f000850ba
+patword 0x007c 0x000c599f000850ba
+patword 0x007d 0x000c599f000850ba
+patword 0x007e 0x000c599f000850ba
+patword 0x007f 0x000c599f000850ba
+patword 0x0080 0x000c599f000850ba
+patword 0x0081 0x000c599f000850ba
+patword 0x0082 0x000c599f000850ba
+patword 0x0083 0x000c599f000850ba
+patword 0x0084 0x000c599f000850ba
+patword 0x0085 0x000c599f000850ba
+patword 0x0086 0x000c599f400850ba
+patword 0x0087 0x000c599f400850ba
+patword 0x0088 0x000c599f600850ba
+patword 0x0089 0x000c599f400850ba
+patword 0x008a 0x000c599f400850ba
+patword 0x008b 0x000c599f400850ba
+patword 0x008c 0x840c599f682e50ba
+patword 0x008d 0x840c599f482850ba
+patword 0x008e 0x840c599f000e50ba
+patword 0x008f 0x840c599f000850ba
+patword 0x0090 0x840c599f000e50ba
+patword 0x0091 0x840c599f000850ba
+patword 0x0092 0x840c599f000e50ba
+patword 0x0093 0x840c599f000850ba
+patword 0x0094 0x840c599f000e50ba
+patword 0x0095 0x840c599f000850ba
+patword 0x0096 0x840c599f000e50ba
+patword 0x0097 0x840c599f000850ba
+patword 0x0098 0x840c599f000e50ba
+patword 0x0099 0x840c599f000850ba
+patword 0x009a 0x840c599f000e50ba
+patword 0x009b 0x840c599f000850ba
+patword 0x009c 0x840c599f000e50ba
+patword 0x009d 0x840c599f000850ba
+patword 0x009e 0x840c599f000e50ba
+patword 0x009f 0x840c599f000850ba
+patword 0x00a0 0x840c599f000e50ba
+patword 0x00a1 0x840c599f000850ba
+patword 0x00a2 0x840c599f000e50ba
+patword 0x00a3 0x840c599f000850ba
+patword 0x00a4 0x840c599f000e50ba
+patword 0x00a5 0x840c599f000850ba
+patword 0x00a6 0x840c599f200e50ba
+patword 0x00a7 0x840c599f000850ba
+patword 0x00a8 0x840c599f000e50ba
+patword 0x00a9 0x840c599f000850ba
+patword 0x00aa 0x840c599f000e50ba
+patword 0x00ab 0x840c599f000850ba
+patword 0x00ac 0x840c599f000e50ba
+patword 0x00ad 0x840c599f000850ba
+patword 0x00ae 0x840c599f000e50ba
+patword 0x00af 0x840c599f000850ba
+patword 0x00b0 0x840c599f000e50ba
+patword 0x00b1 0x840c599f000850ba
+patword 0x00b2 0x840c599f000e50ba
+patword 0x00b3 0x840c599f000850ba
+patword 0x00b4 0x840c599f000e50ba
+patword 0x00b5 0x840c599f000850ba
+patword 0x00b6 0x840c599f000e50ba
+patword 0x00b7 0x840c599f000850ba
+patword 0x00b8 0x840c599f000e50ba
+patword 0x00b9 0x840c599f000850ba
+patword 0x00ba 0x840c599f000e50ba
+patword 0x00bb 0x840c599f000850ba
+patword 0x00bc 0x840c599f000e50ba
+patword 0x00bd 0x840c599f000850ba
+patword 0x00be 0x840c599f282e50ba
+patword 0x00bf 0x840c599f082850ba
+patword 0x00c0 0x840c599f000e50ba
+patword 0x00c1 0x840c599f000850ba
+patword 0x00c2 0x840c599f000e50ba
+patword 0x00c3 0x840c599f000850ba
+patword 0x00c4 0x840c599f000e50ba
+patword 0x00c5 0x840c599f000850ba
+patword 0x00c6 0x840c599f000e50ba
+patword 0x00c7 0x840c599f000850ba
+patword 0x00c8 0x840c599f000e50ba
+patword 0x00c9 0x840c599f000850ba
+patword 0x00ca 0x840c599f000e50ba
+patword 0x00cb 0x840c599f000850ba
+patword 0x00cc 0x840c599f000e50ba
+patword 0x00cd 0x840c599f000850ba
+patword 0x00ce 0x840c599f000e50ba
+patword 0x00cf 0x840c599f000850ba
+patword 0x00d0 0x840c599f000e50ba
+patword 0x00d1 0x840c599f000850ba
+patword 0x00d2 0x840c599f000e50ba
+patword 0x00d3 0x840c599f000850ba
+patword 0x00d4 0x840c599f000e50ba
+patword 0x00d5 0x840c599f000850ba
+patword 0x00d6 0x840c599f000e50ba
+patword 0x00d7 0x840c599f000850ba
+patword 0x00d8 0x840c599f200e50ba
+patword 0x00d9 0x840c599f000850ba
+patword 0x00da 0x840c599f000e50ba
+patword 0x00db 0x840c599f000850ba
+patword 0x00dc 0x840c599f000e50ba
+patword 0x00dd 0x840c599f000850ba
+patword 0x00de 0x840c599f000e50ba
+patword 0x00df 0x840c599f000850ba
+patword 0x00e0 0x840c599f000e50ba
+patword 0x00e1 0x840c599f000850ba
+patword 0x00e2 0x840c599f000e50ba
+patword 0x00e3 0x840c599f000850ba
+patword 0x00e4 0x840c599f000e50ba
+patword 0x00e5 0x840c599f000850ba
+patword 0x00e6 0x840c599f000e50ba
+patword 0x00e7 0x840c599f000850ba
+patword 0x00e8 0x840c599f000e50ba
+patword 0x00e9 0x840c599f000850ba
+patword 0x00ea 0x840c599f000e50ba
+patword 0x00eb 0x840c599f000850ba
+patword 0x00ec 0x840c599f000e50ba
+patword 0x00ed 0x840c599f000850ba
+patword 0x00ee 0x840c599f000e50ba
+patword 0x00ef 0x840c599f000850ba
+patword 0x00f0 0x040c599f000850ba
+patword 0x00f1 0x040c599f000850ba
+patword 0x00f2 0x000c599f000850ba
+patword 0x00f3 0x000c599f000850ba
+patword 0x00f4 0x0008599f200e503a
+patword 0x00f5 0x0008599f0008503a
+patword 0x00f6 0x0008599f200e503a
+patword 0x00f7 0x0008599f0008503a
+patword 0x00f8 0x0008599f0008503a
+patword 0x00f9 0x0008599f0008503a
+patword 0x00fa 0x0008599f0008503a
+patword 0x00fb 0x0008599f0008503a
+patword 0x00fc 0x0008599f0008503a
+patword 0x00fd 0x0008599f0008503a
+patword 0x00fe 0x0008599f0008503a
+patword 0x00ff 0x0008599f0008503a
+patword 0x0100 0x0008599f0008503a
+patword 0x0101 0x0008599f0008503a
+patword 0x0102 0x0008599f0008503a
+patword 0x0103 0x0008599f0008503a
+patword 0x0104 0x0008599f0008503a
+patword 0x0105 0x0008599f0008503a
+patword 0x0106 0x0008599f0008503a
+patword 0x0107 0x0008599f0008503a
+patword 0x0108 0x0008599f0008503a
+patword 0x0109 0x0008599f0008503a
+patword 0x010a 0x0008599f0008503a
+patword 0x010b 0x0008599f0008503a
+patword 0x010c 0x0008599f0008503a
+patword 0x010d 0x0008599f0008503a
+patword 0x010e 0x0008599f0008503a
+patword 0x010f 0x0008599f0008503a
+patword 0x0110 0x0008599f0008503a
+patword 0x0111 0x0008599f0008503a
+patioctrl 0x8f0effff6dbffdbf
+patlimits 0x0000 0x0110
+patloop0 0x00be 0x00ef
+patnloop0 199
+patloop1 0x0400 0x0400
+patnloop1 0
+patloop2 0x0400 0x0400
+patnloop2 0
+patwait0 0x002e
+patwaittime0 800
+patwait1 0x0400
+patwaittime1 0
+patwait2 0x0400
+patwaittime2 0

slsDetectorServers/mythen3DetectorServer/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_executable(mythen3DetectorServer_virtual
     slsDetectorFunctionList.c
+    mythen3.c
     ../slsDetectorServer/src/slsDetectorServer.c
     ../slsDetectorServer/src/slsDetectorServer_funcs.c
     ../slsDetectorServer/src/communication_funcs.c
@@ -10,7 +11,8 @@ add_executable(mythen3DetectorServer_virtual
     ../slsDetectorServer/src/LTC2620_Driver.c
     ../slsDetectorServer/src/ALTERA_PLL_CYCLONE10.c   
     ../slsDetectorServer/src/programFpgaNios.c
-    ../slsDetectorServer/src/readDefaultPattern.c         
+    ../slsDetectorServer/src/readDefaultPattern.c 
+    ../slsDetectorServer/src/loadPattern.c         
     ../slsDetectorServer/src/sharedMemory.c
 )
 

slsDetectorServers/mythen3DetectorServer/Makefile

@@ -13,7 +13,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)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c
+SRCS	+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c mythen3.c
 
 OBJS 	= 	$(SRCS:.c=.o) 
  
@@ -40,4 +40,4 @@ clean:
 	rm -rf $(DESTDIR)/$(PROGS)  *.o *.gdb $(main_src)*.o
 	
 
-	
+	

slsDetectorServers/mythen3DetectorServer/bin/DefaultPattern_mythen3.txt

@@ -0,0 +1,256 @@
+patword 0x0000 0x0000000000000000
+patword 0x0001 0x0000000000000000
+patword 0x0002 0x0000000000000000
+patword 0x0003 0x0000000000000000
+patword 0x0004 0x0000000000000000
+patword 0x0005 0x0000000000000000
+patword 0x0006 0x0000000000c00000
+patword 0x0007 0x0000000000c00000
+patword 0x0008 0x0000000000c00000
+patword 0x0009 0x0000000000c00000
+patword 0x000a 0x0000000000c00000
+patword 0x000b 0x0000000000c00000
+patword 0x000c 0x0000000000000000
+patword 0x000d 0x0000000000000000
+patword 0x000e 0x0000000000000000
+patword 0x000f 0x0000000000000000
+patword 0x0010 0x0000000000000000
+patword 0x0011 0x0000000000000000
+patword 0x0012 0x0000000000200000
+patword 0x0013 0x0000000000200000
+patword 0x0014 0x0000000000e00000
+patword 0x0015 0x0000000000e00000
+patword 0x0016 0x0000000000e00000
+patword 0x0017 0x0000000000e00000
+patword 0x0018 0x0000000000e00000
+patword 0x0019 0x0000000000e00000
+patword 0x001a 0x0000000000e00000
+patword 0x001b 0x0000000000e00000
+patword 0x001c 0x0000000000200000
+patword 0x001d 0x0000000000200000
+patword 0x001e 0x0000000000200000
+patword 0x001f 0x0000000000200000
+patword 0x0020 0x0000000000200000
+patword 0x0021 0x0000000000200000
+patword 0x0022 0x0000000000200000
+patword 0x0023 0x0000000000200000
+patword 0x0024 0x0000000000200000
+patword 0x0025 0x0000000000200000
+patword 0x0026 0x0000000000200000
+patword 0x0027 0x0000000000200000
+patword 0x0028 0x0000000000200000
+patword 0x0029 0x0000000001200000
+patword 0x002a 0x0000000000200000
+patword 0x002b 0x0000000000200000
+patword 0x002c 0x0000000000200000
+patword 0x002d 0x0000000000200000
+patword 0x002e 0x0000000000200000
+patword 0x002f 0x0000000000200000
+patword 0x0030 0x0000000000200000
+patword 0x0031 0x0000000000200000
+patword 0x0032 0x0000000001200000
+patword 0x0033 0x0000000000200000
+patword 0x0034 0x0000000000200000
+patword 0x0035 0x0000000000200000
+patword 0x0036 0x0000000000200000
+patword 0x0037 0x0000000000200000
+patword 0x0038 0x0000000000200000
+patword 0x0039 0x0000000000200000
+patword 0x003a 0x0000000000200000
+patword 0x003b 0x0000000001200000
+patword 0x003c 0x0000000000200000
+patword 0x003d 0x0000000000200000
+patword 0x003e 0x0000000000200000
+patword 0x003f 0x0000000000200000
+patword 0x0040 0x0000000000200000
+patword 0x0041 0x0000000000200000
+patword 0x0042 0x0000000000200000
+patword 0x0043 0x0000000000200000
+patword 0x0044 0x0000000001200000
+patword 0x0045 0x0000000000200000
+patword 0x0046 0x0000000000200000
+patword 0x0047 0x0000000000200000
+patword 0x0048 0x0000000000200000
+patword 0x0049 0x0000000000200000
+patword 0x004a 0x0000000000200000
+patword 0x004b 0x0000000000200000
+patword 0x004c 0x0000000000200000
+patword 0x004d 0x0000000001200000
+patword 0x004e 0x0000000000200000
+patword 0x004f 0x0000000000200000
+patword 0x0050 0x0000000000200000
+patword 0x0051 0x0000000000200000
+patword 0x0052 0x0000000000200000
+patword 0x0053 0x0000000000200000
+patword 0x0054 0x0000000000200000
+patword 0x0055 0x0000000000200000
+patword 0x0056 0x0000000001200000
+patword 0x0057 0x0000000000200000
+patword 0x0058 0x0000000000200000
+patword 0x0059 0x0000000000200000
+patword 0x005a 0x0000000000280000
+patword 0x005b 0x0000000000280000
+patword 0x005c 0x0000000000280000
+patword 0x005d 0x0000000000280000
+patword 0x005e 0x0000000000280000
+patword 0x005f 0x0000000001280000
+patword 0x0060 0x0000000000280000
+patword 0x0061 0x0000000000200000
+patword 0x0062 0x0000000000200000
+patword 0x0063 0x0000000000200000
+patword 0x0064 0x0000000000200000
+patword 0x0065 0x0000000000200000
+patword 0x0066 0x0000000000200000
+patword 0x0067 0x0000000000200000
+patword 0x0068 0x0000000001200000
+patword 0x0069 0x0000000000200000
+patword 0x006a 0x0000000000200000
+patword 0x006b 0x0000000000200000
+patword 0x006c 0x0000000000200000
+patword 0x006d 0x0000000000200000
+patword 0x006e 0x0000000000200000
+patword 0x006f 0x0000000000200000
+patword 0x0070 0x0000000000200000
+patword 0x0071 0x0000000001200000
+patword 0x0072 0x0000000000200000
+patword 0x0073 0x0000000000200000
+patword 0x0074 0x0000000000200000
+patword 0x0075 0x0000000000200000
+patword 0x0076 0x0000000000200000
+patword 0x0077 0x0000000000200000
+patword 0x0078 0x0000000000200000
+patword 0x0079 0x0000000000200000
+patword 0x007a 0x0000000001200000
+patword 0x007b 0x0000000000200000
+patword 0x007c 0x0000000000200000
+patword 0x007d 0x0000000000200000
+patword 0x007e 0x0000000000280000
+patword 0x007f 0x0000000000280000
+patword 0x0080 0x0000000000280000
+patword 0x0081 0x0000000000280000
+patword 0x0082 0x0000000000280000
+patword 0x0083 0x0000000001280000
+patword 0x0084 0x0000000000280000
+patword 0x0085 0x0000000000200000
+patword 0x0086 0x0000000000200000
+patword 0x0087 0x0000000000200000
+patword 0x0088 0x0000000000200000
+patword 0x0089 0x0000000000200000
+patword 0x008a 0x0000000000200000
+patword 0x008b 0x0000000000200000
+patword 0x008c 0x0000000001200000
+patword 0x008d 0x0000000000200000
+patword 0x008e 0x0000000000200000
+patword 0x008f 0x0000000000200000
+patword 0x0090 0x0000000000200000
+patword 0x0091 0x0000000000200000
+patword 0x0092 0x0000000000200000
+patword 0x0093 0x0000000000200000
+patword 0x0094 0x0000000000200000
+patword 0x0095 0x0000000001200000
+patword 0x0096 0x0000000000200000
+patword 0x0097 0x0000000000200000
+patword 0x0098 0x0000000000200000
+patword 0x0099 0x0000000000200000
+patword 0x009a 0x0000000000200000
+patword 0x009b 0x0000000000200000
+patword 0x009c 0x0000000000200000
+patword 0x009d 0x0000000000200000
+patword 0x009e 0x0000000001200000
+patword 0x009f 0x0000000000200000
+patword 0x00a0 0x0000000000200000
+patword 0x00a1 0x0000000000200000
+patword 0x00a2 0x0000000000200000
+patword 0x00a3 0x0000000000200000
+patword 0x00a4 0x0000000000200000
+patword 0x00a5 0x0000000000200000
+patword 0x00a6 0x0000000000200000
+patword 0x00a7 0x0000000001200000
+patword 0x00a8 0x0000000000200000
+patword 0x00a9 0x0000000000200000
+patword 0x00aa 0x0000000000200000
+patword 0x00ab 0x0000000000200000
+patword 0x00ac 0x0000000000200000
+patword 0x00ad 0x0000000000200000
+patword 0x00ae 0x0000000000200000
+patword 0x00af 0x0000000000200000
+patword 0x00b0 0x0000000001200000
+patword 0x00b1 0x0000000000200000
+patword 0x00b2 0x0000000000200000
+patword 0x00b3 0x0000000000200000
+patword 0x00b4 0x0000000000200000
+patword 0x00b5 0x0000000000200000
+patword 0x00b6 0x0000000000200000
+patword 0x00b7 0x0000000000200000
+patword 0x00b8 0x0000000000200000
+patword 0x00b9 0x0000000001200000
+patword 0x00ba 0x0000000000200000
+patword 0x00bb 0x0000000000200000
+patword 0x00bc 0x0000000000200000
+patword 0x00bd 0x0000000000200000
+patword 0x00be 0x0000000000200000
+patword 0x00bf 0x0000000000200000
+patword 0x00c0 0x0000000000200000
+patword 0x00c1 0x0000000000200000
+patword 0x00c2 0x0000000001200000
+patword 0x00c3 0x0000000000200000
+patword 0x00c4 0x0000000000200000
+patword 0x00c5 0x0000000000200000
+patword 0x00c6 0x0000000000300000
+patword 0x00c7 0x0000000000300000
+patword 0x00c8 0x0000000000300000
+patword 0x00c9 0x0000000000300000
+patword 0x00ca 0x0000000000300000
+patword 0x00cb 0x0000000000200000
+patword 0x00cc 0x0000000000200000
+patword 0x00cd 0x0000000000200000
+patword 0x00ce 0x0000000000200000
+patword 0x00cf 0x0000000000200000
+patword 0x00d0 0x0000000000200000
+patword 0x00d1 0x0000000000200000
+patword 0x00d2 0x0000000000000000
+patword 0x00d3 0x0000000000000000
+patword 0x00d4 0x0000000000000000
+patword 0x00d5 0x0000000000000000
+patword 0x00d6 0x0000000000000000
+patword 0x00d7 0x0000000000000000
+patword 0x00d8 0x0000000000000000
+patword 0x00d9 0x0000000000000000
+patword 0x00da 0x0000000000c00000
+patword 0x00db 0x0000000000c00000
+patword 0x00dc 0x0000000000c00000
+patword 0x00dd 0x0000000000c00000
+patword 0x00de 0x0000000000c00000
+patword 0x00df 0x0000000000c00000
+patword 0x00e0 0x0000000000c00000
+patword 0x00e1 0x0000000000c00000
+patword 0x00e2 0x0000000000c00000
+patword 0x00e3 0x0000000000c00000
+patword 0x00e4 0x0000000000000000
+patword 0x00e5 0x0000000000000000
+patword 0x00e6 0x0000000000000000
+patword 0x00e7 0x0000000000000000
+patword 0x00e8 0x0000000000000000
+patword 0x00e9 0x0000000000000000
+patword 0x00ea 0x0000000000000000
+patword 0x00eb 0x0000000000000000
+patword 0x00ec 0x0000000000000000
+patword 0x00ed 0x0000000000000000
+patword 0x00ee 0x0000000000000000
+patword 0x00ef 0x0000000000000000
+patword 0x00f0 0x0000000000000000
+patword 0x00f1 0x0000000000000000
+patword 0x00f2 0x0000000000000000
+patlimits 0x0000 0x00f2
+patloop0 0x0400 0x0400
+patnloop0 0
+patloop1 0x0400 0x0400
+patnloop1 0
+patloop2 0x0400 0x0400
+patnloop2 0
+patwait0 0x0400
+patwaittime0 0
+patwait1 0x0400
+patwaittime1 0
+patwait2 0x0400
+patwaittime2 0

slsDetectorServers/mythen3DetectorServer/mythen3.c

@@ -0,0 +1,374 @@
+
+#include "clogger.h"
+#include "common.h"
+#include "mythen3.h"
+#include "sls/ansi.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorServer_defs.h"
+
+#include <string.h>
+
+/*
+// Common C/C++ structure to handle pattern data
+typedef struct __attribute__((packed)) {
+    uint64_t word[MAX_PATTERN_LENGTH];
+    uint64_t ioctrl;
+    uint32_t limits[2];
+    // loop0 start, loop0 stop .. loop2 start, loop2 stop
+    uint32_t loop[6];
+    uint32_t nloop[3];
+    uint32_t wait[3];
+    uint64_t waittime[3];
+} patternParameters;
+*/
+
+int chipStatusRegister=0;
+
+int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
+
+int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
+
+extern enum TLogLevel trimmingPrint ;
+
+
+int getChipStatusRegister(){
+  return chipStatusRegister;
+}
+
+int gainCapsToCsr(int caps){
+  //Translates bit representation
+  int csr = 0;
+  if (!(caps & M3_C10pre))
+    csr |= 1 << _CSR_C10pre;
+  if (caps & M3_C15sh)
+    csr |= 1 << CSR_C15sh;
+  if (caps & M3_C30sh)
+    csr |= 1 << CSR_C30sh;
+  if (caps & M3_C50sh)
+    csr |= 1 << CSR_C50sh;
+  if (caps & M3_C225ACsh)
+    csr |= 1 << CSR_C225ACsh;
+  if (!(caps & M3_C15pre))
+    csr |= 1 << _CSR_C15pre;
+
+  return csr;
+}
+
+int csrToGainCaps(int csr){
+  //Translates bit representation
+  int caps = 0;
+  if (!(csr & (1 << _CSR_C10pre)))
+    caps |= M3_C10pre;
+  if (csr & (1 << CSR_C15sh))
+    caps |= M3_C15sh;
+  if (csr & (1 << CSR_C30sh))
+    caps |= M3_C30sh;
+  if (csr & (1 << CSR_C50sh))
+    caps |= M3_C50sh;
+  if (csr & (1 << CSR_C225ACsh))
+    caps |= M3_C225ACsh;
+  if (!(csr & (1 << _CSR_C15pre)))
+    caps |= M3_C15pre;
+
+  return caps;
+}
+
+patternParameters *setChipStatusRegisterPattern(int csr) {
+  int iaddr=0;
+  int  nbits=18;
+  int error=0;
+  //int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
+  int patword=0;
+  
+  patternParameters *pat = malloc(sizeof(patternParameters));
+  memset(pat, 0, sizeof(patternParameters));
+  
+  patword=setBit(SIGNAL_STATLOAD,patword);
+  for (int i=0; i<2; i++)
+    pat->word[iaddr++]=patword;
+  patword=setBit(SIGNAL_resStorage,patword);
+  patword=setBit(SIGNAL_resCounter,patword);
+  for (int i=0; i<8; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_resStorage,patword);
+  patword=clearBit(SIGNAL_resCounter,patword);
+  for (int i=0; i<8; i++)
+    pat->word[iaddr++]=patword;
+  //#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
+  for (int ib=nbits-1; ib>=0; ib--) {
+    if (csr&(1<<ib))
+      patword=setBit(SIGNAL_serialIN,patword);
+    else
+      patword=clearBit(SIGNAL_serialIN,patword);
+    for (int i=0; i<4; i++)
+      pat->word[iaddr++]=patword;
+    patword=setBit(SIGNAL_CHSclk,patword);
+    pat->word[iaddr++]=patword;
+    patword=clearBit(SIGNAL_CHSclk,patword);
+    pat->word[iaddr++]=patword;
+  }
+
+  patword=clearBit(SIGNAL_serialIN,patword);
+  for (int i=0; i<2; i++)
+    pat->word[iaddr++]=patword;
+  patword=setBit(SIGNAL_STO,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_STO,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_STATLOAD,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  // set pattern wait address
+  for (int i = 0; i <= 2; i++)
+    pat->wait[i]=MAX_PATTERN_LENGTH - 1;
+  // pattern loop
+  for (int i = 0; i <= 2; i++) {
+    //int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
+    pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1;
+    pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1;
+    pat->nloop[i]=0;
+  }
+  
+  // pattern limits
+  {
+    pat->limits[0]=0;
+    pat->limits[1]=iaddr;
+  }
+  
+  if (error != 0) {
+    free(pat);
+    return NULL;
+  }
+  chipStatusRegister=csr;
+  return pat;
+
+}
+
+patternParameters *setInterpolation(int mask) {
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_interp);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_interp);
+
+  return setChipStatusRegisterPattern(csr);
+}
+
+
+
+patternParameters *setPumpProbe(int mask) {
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_pumprobe);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_pumprobe);
+
+  return setChipStatusRegisterPattern(csr);
+
+}
+patternParameters *setDigitalPulsing(int mask) {
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_dpulse);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_dpulse);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+patternParameters *setAnalogPulsing(int mask){
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_apulse);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_apulse);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+patternParameters *setNegativePolarity(int mask){
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_invpol);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_invpol);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+
+patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {
+
+  patternParameters *pat = malloc(sizeof(patternParameters));
+  memset(pat, 0, sizeof(patternParameters));
+  
+
+    // validate
+  for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS; ichan < ichip * NCHAN_1_COUNTER * NCOUNTERS+NCHAN_1_COUNTER*NCOUNTERS; ichan++) {
+    if (trimbits[ichan]<0)  {
+      LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - setting it to 0\n",
+		     trimbits[ichan], ichan));
+      trimbits[ichan]=0;
+    }
+    if (trimbits[ichan] > 63) {
+      LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - settings it to 63\n",
+		     trimbits[ichan], ichan));
+      trimbits[ichan]=63;
+    }
+  }
+  LOG(logINFO, ("Trimbits validated\n"));
+  trimmingPrint = logDEBUG5;
+
+    
+  // trimming
+  int error = 0;
+  uint64_t patword = 0;
+  int iaddr = 0;
+  
+  LOG(logDEBUG1, (" Chip %d\n", ichip));
+  iaddr = 0;
+  patword = 0;
+  pat->word[iaddr++]=patword;
+  
+  // chip select
+  patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
+  pat->word[iaddr++]=patword;
+  
+  // reset trimbits
+  patword = setBit(SIGNAL_resStorage, patword);
+  patword = setBit(SIGNAL_resCounter, patword);
+  pat->word[iaddr++]=patword;
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_resStorage, patword);
+  patword = clearBit(SIGNAL_resCounter, patword);
+  pat->word[iaddr++]=patword;
+  pat->word[iaddr++]=patword;
+  
+  // select first channel
+  patword = setBit(SIGNAL_CHSserialIN, patword);
+  pat->word[iaddr++]=patword;
+  // 1 clk pulse
+  patword = setBit(SIGNAL_CHSclk, patword);
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_CHSclk, patword);
+  // clear 1st channel
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_CHSserialIN, patword);
+  // 2 clk pulses
+  for (int i = 0; i < 2; i++) {
+    patword = setBit(SIGNAL_CHSclk, patword);
+    pat->word[iaddr++]=patword;
+    patword = clearBit(SIGNAL_CHSclk, patword);
+    pat->word[iaddr++]=patword;
+  }
+  
+  // for each channel (all chips)
+  for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
+    LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
+    int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+		       NCOUNTERS * ich] +
+      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+	       NCOUNTERS * ich + 1] *
+      64 +
+      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+	       NCOUNTERS * ich + 2] *
+      64 * 64;
+    
+    // push 6 0 bits
+    for (int i = 0; i < 3; i++) {
+      patword = clearBit(SIGNAL_serialIN, patword);
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    
+    for (int i = 0; i < 3; i++) {
+      if (mask[i])
+	patword = setBit(SIGNAL_serialIN, patword);
+      else
+	patword = clearBit(SIGNAL_serialIN, patword);
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    
+    // deserialize
+    for (int i = 0; i < 18; i++) {
+      if (val & (1 << i)) {
+	patword = setBit(SIGNAL_serialIN, patword);
+      } else {
+	patword = clearBit(SIGNAL_serialIN, patword);
+      }
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    pat->word[iaddr++]=patword;
+    pat->word[iaddr++]=patword;
+    
+    // move to next channel
+    for (int i = 0; i < 3; i++) {
+      patword = setBit(SIGNAL_CHSclk, patword);
+      pat->word[iaddr++]=patword;
+      patword = clearBit(SIGNAL_CHSclk, patword);
+      pat->word[iaddr++]=patword;
+    }
+  }
+  // chip unselect
+  patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
+  pat->word[iaddr++]=patword;
+  
+  // last iaddr check
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  // set pattern wait address
+  for (int i = 0; i <= 2; i++)
+    pat->wait[i]=MAX_PATTERN_LENGTH - 1;
+  // pattern loop
+  for (int i = 0; i <= 2; i++) {
+    //int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
+    pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1;
+    pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1;
+    pat->nloop[i]=0;
+  }
+  
+  // pattern limits
+  {
+    pat->limits[0]=0;
+    pat->limits[1]=iaddr;
+  }
+  
+  trimmingPrint = logINFO;
+  if (error == 0) {
+    
+    LOG(logINFO, ("All trimbits have been loaded\n"));
+  } else {
+    free(pat);
+    return NULL;
+  }
+  return pat;
+}

slsDetectorServers/mythen3DetectorServer/mythen3.h

@@ -0,0 +1,68 @@
+#ifndef MYTHEN3_H
+#define MYTHEN3_H
+
+#include "Pattern.h"
+
+/** Signal Definitions */
+#define SIGNAL_TBLoad_1    (0)
+#define SIGNAL_TBLoad_2    (1)
+#define SIGNAL_TBLoad_3    (2)
+#define SIGNAL_TBLoad_4    (3)
+#define SIGNAL_TBLoad_5    (4)
+#define SIGNAL_TBLoad_6    (5)
+#define SIGNAL_TBLoad_7    (6)
+#define SIGNAL_TBLoad_8    (7)
+#define SIGNAL_TBLoad_9    (8)
+#define SIGNAL_TBLoad_10   (9)
+#define SIGNAL_AnaMode     (10)
+#define SIGNAL_CHSserialIN (11)
+#define SIGNAL_READOUT     (12)
+#define SIGNAL_pulse       (13)
+#define SIGNAL_EN1         (14)
+#define SIGNAL_EN2         (15)
+#define SIGNAL_EN3         (16)
+#define SIGNAL_clk         (17)
+#define SIGNAL_SRmode      (18)
+#define SIGNAL_serialIN    (19)
+#define SIGNAL_STO         (20)
+#define SIGNAL_STATLOAD    (21)
+#define SIGNAL_resStorage  (22)
+#define SIGNAL_resCounter  (23)
+#define SIGNAL_CHSclk      (24)
+#define SIGNAL_exposing    (25)
+
+
+//CHIP STARTUS REGISTER BITS
+#define CSR_spypads  0
+#define CSR_invpol  4
+#define CSR_dpulse  5
+#define CSR_interp  6
+#define _CSR_C10pre  7 //#default, negative polarity
+#define CSR_pumprobe  8
+#define CSR_apulse  9
+#define CSR_C15sh  10 
+#define CSR_C30sh  11 //#default
+#define CSR_C50sh  12
+#define CSR_C225ACsh  13 // Connects 225fF SHAPER AC cap (1: 225 to shaper, 225 to GND. 0: 450 to shaper) 
+#define _CSR_C15pre  14 // negative polarity
+
+#define CSR_default  (1<<_CSR_C10pre )|(1<< CSR_C30sh)
+
+#define GAIN_MASK ((1 << _CSR_C10pre) | ( 1 << CSR_C15sh) | (1 << CSR_C30sh) | (1 << CSR_C50sh) | (1 << CSR_C225ACsh) | ( 1 << _CSR_C15pre))
+
+
+int setBit(int ibit, int patword);
+int clearBit(int ibit, int patword);
+int getChipStatusRegister();
+int gainCapsToCsr(int caps);
+int csrToGainCaps(int csr);
+
+patternParameters *setChipStatusRegisterPattern(int csr);
+patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits);
+patternParameters *setInterpolation(int mask);
+patternParameters *setPumpProbe(int mask);
+patternParameters *setDigitalPulsing(int mask);
+patternParameters *setAnalogPulsing(int mask);
+patternParameters *setNegativePolarity(int mask);
+
+#endif

slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c

@@ -5,6 +5,8 @@
 #include "RegisterDefs.h"
 #include "clogger.h"
 #include "common.h"
+#include "mythen3.h"
+#include "loadPattern.h"
 #include "sharedMemory.h"
 #include "sls/versionAPI.h"
 #ifdef VIRTUAL
@@ -19,8 +21,6 @@
 #include <time.h>
 #endif
 
-/// NOT the right place to put it!
-int setChipStatusRegister(int csr);
 
 // Global variable from slsDetectorServer_funcs
 extern int debugflag;
@@ -47,11 +47,12 @@ enum detectorSettings thisSettings;
 sls_detector_module *detectorModules = NULL;
 int *detectorChans = NULL;
 int *detectorDacs = NULL;
+int *channelMask=NULL;
 
-enum TLogLevel trimmingPrint = logINFO;
 int32_t clkPhase[NUM_CLOCKS] = {};
 uint32_t clkDivider[NUM_CLOCKS] = {};
 
+enum TLogLevel trimmingPrint = logINFO;
 int highvoltage = 0;
 int detPos[2] = {};
 int64_t exptimeReg[NCOUNTERS] = {0, 0, 0};
@@ -374,7 +375,11 @@ void allocateDetectorStructureMemory() {
     // Allocation of memory
     detectorModules = malloc(sizeof(sls_detector_module));
     detectorChans = malloc(NCHIP * NCHAN * sizeof(int));
+    channelMask = malloc(NCHIP * NCHAN * sizeof(char));
+    memset(channelMask, 0, NCHIP * NCHAN * sizeof(char));
     detectorDacs = malloc(NDAC * sizeof(int));
+
+    
     LOG(logDEBUG1,
         ("modules from 0x%x to 0x%x\n", detectorModules, detectorModules));
     LOG(logDEBUG1, ("chans from 0x%x to 0x%x\n", detectorChans, detectorChans));
@@ -512,11 +517,11 @@ void setupDetector() {
     }
 
     powerChip(1);
-    if (initError != FAIL) {
+
-      initError = setChipStatusRegister(CSR_default);
+    if (!initError) {
-      //loadDefaultPattern(DEFAULT_PATTERN_FILE, initErrorMessage);
+      setChipStatusRegister(CSR_default);
-      //startStateMachine(); //this was missing in previous code! runs the default pattern
     }
+
     setAllTrimbits(DEFAULT_TRIMBIT_VALUE);
 }
 
@@ -1052,72 +1057,44 @@ int64_t getMeasurementTime() {
 
 /* parameters - module, speed, readout */
 
-int setModule(sls_detector_module myMod, char *mess) {
+int setDACS(int* dacs){
-
-    LOG(logINFO, ("Setting module\n"));
-
-    // settings
-    if (myMod.reg >= 0) {
-        setSettings((enum detectorSettings)myMod.reg);
-        if (getSettings() != (enum detectorSettings)myMod.reg) {
-            sprintf(
-                mess,
-                "Could not set module. Could not set settings to %d, read %d\n",
-                myMod.reg, (int)getSettings());
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        detectorModules->reg = myMod.reg;
-    }
-    // custom trimbit file
-    else {
-        // changed for setsettings (direct),
-        // custom trimbit file (setmodule with myMod.reg as -1),
-        // change of dac (direct)
-        for (int i = 0; i < NCOUNTERS; ++i) {
-            setThresholdEnergy(i, -1);
-        }
-    }
-
-    // dacs
     for (int i = 0; i < NDAC; ++i) {
-        // ignore dacs with -1
+        if (dacs[i] != -1) {
-        if (myMod.dacs[i] != -1) {
+            setDAC((enum DACINDEX)i, dacs[i], 0);
-            setDAC((enum DACINDEX)i, myMod.dacs[i], 0);
+            if (dacs[i] != detectorDacs[i]) {
-            if (myMod.dacs[i] != detectorDacs[i]) {
                 // dont complain if that counter was disabled
                 if ((i == M_VTH1 || i == M_VTH2 || i == M_VTH3) &&
                     (detectorDacs[i] == DEFAULT_COUNTER_DISABLED_VTH_VAL)) {
                     continue;
                 }
-                sprintf(mess,
-                        "Could not set module. Could not set dac %d, wrote %d, "
-                        "read %d\n",
-                        i, myMod.dacs[i], detectorDacs[i]);
-                LOG(logERROR, (mess));
                 return FAIL;
             }
         }
     }
+    return OK;
+}
 
-    // if settings given and cannot be validated (after setting dacs), return
+
-    // error
+int setModule(sls_detector_module myMod, char *mess) {
-    if (myMod.reg >= 0) {
+    LOG(logINFO, ("Setting module\n"));
-        if (getSettings() != (enum detectorSettings)myMod.reg) {
+
-            sprintf(
+    if (setChipStatusRegister(myMod.reg)){
-                mess,
+        sprintf(mess, "Could not CSR from module\n");
-                "Could not set module. The dacs in file do not correspond to "
+        LOG(logERROR, (mess));
-                "settings %d\n",
+        return FAIL;
-                myMod.reg);
+    }
-            LOG(logERROR, (mess));
+
-            return FAIL;
+    if (setDACS(myMod.dacs)){
-        }
+        sprintf(mess, "Could not set dacs\n");
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
-    // threshold
     for (int i = 0; i < NCOUNTERS; ++i) {
         if (myMod.eV[i] >= 0) {
             setThresholdEnergy(i, myMod.eV[i]);
+        }else{
+            setThresholdEnergy(i, -1);
         }
     }
 
@@ -1136,155 +1113,31 @@ int setModule(sls_detector_module myMod, char *mess) {
     return OK;
 }
 
-int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
-
-int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
-
 int setTrimbits(int *trimbits) {
-    LOG(logINFOBLUE, ("Setting trimbits\n"));
-
-    // validate
-    for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
-        if (trimbits[ichan] < 0 || trimbits[ichan] > 63) {
-            LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid\n",
-                           trimbits[ichan], ichan));
-            return FAIL;
-        }
-    }
-    LOG(logINFO, ("Trimbits validated\n"));
-    trimmingPrint = logDEBUG5;
-
     // remember previous run clock
     uint32_t prevRunClk = clkDivider[SYSTEM_C0];
-
+    patternParameters *pat = NULL;
+    int error = 0;
     // set to trimming clock
     if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
         LOG(logERROR,
             ("Could not start trimming. Could not set to trimming clock\n"));
         return FAIL;
     }
-
+    /////////////////////////////////////////////////////////////////
-    // trimming
-    int error = 0;
-    uint64_t patword = 0;
-    int iaddr = 0;
     for (int ichip = 0; ichip < NCHIP; ichip++) {
-        if (error != 0) {
-            break;
-        }
-        LOG(logDEBUG1, (" Chip %d\n", ichip));
-        iaddr = 0;
-        patword = 0;
-        writePatternWord(iaddr++, patword);
 
-        // chip select
+        pat = setChannelRegisterChip(ichip, channelMask,
-        patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
+                                     trimbits); // change here!!!
-        writePatternWord(iaddr++, patword);
+        if (pat) {
-
+            error |= loadPattern(pat);
-        // reset trimbits
+            if (error == 0)
-        patword = setBit(SIGNAL_resStorage, patword);
+                startPattern();
-        patword = setBit(SIGNAL_resCounter, patword);
+            free(pat);
-        writePatternWord(iaddr++, patword);
+        } else
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_resStorage, patword);
-        patword = clearBit(SIGNAL_resCounter, patword);
-        writePatternWord(iaddr++, patword);
-        writePatternWord(iaddr++, patword);
-
-        // select first channel
-        patword = setBit(SIGNAL_CHSserialIN, patword);
-        writePatternWord(iaddr++, patword);
-        // 1 clk pulse
-        patword = setBit(SIGNAL_CHSclk, patword);
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_CHSclk, patword);
-        // clear 1st channel
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_CHSserialIN, patword);
-        // 2 clk pulses
-        for (int i = 0; i < 2; i++) {
-            patword = setBit(SIGNAL_CHSclk, patword);
-            writePatternWord(iaddr++, patword);
-            patword = clearBit(SIGNAL_CHSclk, patword);
-            writePatternWord(iaddr++, patword);
-        }
-
-        // for each channel (all chips)
-        for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
-            LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
-            int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich] +
-                      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich + 1] *
-                          64 +
-                      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich + 2] *
-                          64 * 64;
-
-            // push 6 0 bits
-            for (int i = 0; i < 6; i++) {
-                patword = clearBit(SIGNAL_serialIN, patword);
-                patword = clearBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-                patword = setBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-
-            // deserialize
-            for (int i = 0; i < 18; i++) {
-                if (val & (1 << i)) {
-                    patword = setBit(SIGNAL_serialIN, patword);
-                } else {
-                    patword = clearBit(SIGNAL_serialIN, patword);
-                }
-                patword = clearBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-
-                patword = setBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-            writePatternWord(iaddr++, patword);
-            writePatternWord(iaddr++, patword);
-
-            // move to next channel
-            for (int i = 0; i < 3; i++) {
-                patword = setBit(SIGNAL_CHSclk, patword);
-                writePatternWord(iaddr++, patword);
-                patword = clearBit(SIGNAL_CHSclk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-        }
-        // chip unselect
-        patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
-        writePatternWord(iaddr++, patword);
-
-        // last iaddr check
-        if (iaddr >= MAX_PATTERN_LENGTH) {
-            LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
-                           iaddr, MAX_PATTERN_LENGTH));
             error = 1;
-            break;
-        }
-
-        // set pattern wait address
-        for (int i = 0; i <= 2; i++)
-            setPatternWaitAddress(i, MAX_PATTERN_LENGTH - 1);
-
-        // pattern loop
-        for (int i = 0; i <= 2; i++) {
-            int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
-            setPatternLoop(i, &stop, &stop, &nloop);
-        }
-
-        // pattern limits
-        {
-            int start = 0, nloop = 0;
-            setPatternLoop(-1, &start, &iaddr, &nloop);
-        }
-        // send pattern to the chips
-        startPattern();
     }
-
+    /////////////////////////////////////////////////////////////////
     if (error == 0) {
         // copy trimbits locally
         for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
@@ -1292,7 +1145,6 @@ int setTrimbits(int *trimbits) {
         }
         LOG(logINFO, ("All trimbits have been loaded\n"));
     }
-
     trimmingPrint = logINFO;
     // set back to previous clock
     if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
@@ -1303,7 +1155,6 @@ int setTrimbits(int *trimbits) {
     if (error != 0) {
         return FAIL;
     }
-
     return OK;
 }
 
@@ -1522,8 +1373,16 @@ int setHighVoltage(int val) {
     return highvoltage;
 }
 
+int isMaster(){
+    return !(bus_r(0x18) >> 31);
+}
+
 /* parameters - timing */
 void setTiming(enum timingMode arg) {
+    
+    if (!isMaster() && arg == AUTO_TIMING)
+        arg = TRIGGER_EXPOSURE;
+
     uint32_t addr = CONFIG_REG;
     switch (arg) {
     case AUTO_TIMING:
@@ -2772,76 +2631,51 @@ int getNumberOfDACs() { return NDAC; }
 int getNumberOfChannelsPerChip() { return NCHAN; }
 
 int setChipStatusRegister(int csr) {
-  int iaddr=0;
+    uint32_t prevRunClk = clkDivider[SYSTEM_C0];
-  int  nbits=18;
+    patternParameters *pat = NULL;
-  int error=0;
-  //int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
-  int patword=0;
-  patword=setBit(SIGNAL_STATLOAD,patword);
-  for (int i=0; i<2; i++)
-    writePatternWord(iaddr++, patword);
-  patword=setBit(SIGNAL_resStorage,patword);
-  patword=setBit(SIGNAL_resCounter,patword);
-  for (int i=0; i<8; i++)
-    writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_resStorage,patword);
-  patword=clearBit(SIGNAL_resCounter,patword);
-  for (int i=0; i<8; i++)
-    writePatternWord(iaddr++, patword);
-  //#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
-  for (int ib=nbits-1; ib>=0; ib--) {
-    if (csr&(1<<ib))
-      patword=setBit(SIGNAL_serialIN,patword);
-    else
-      patword=clearBit(SIGNAL_serialIN,patword);
-    for (int i=0; i<4; i++)
-      writePatternWord(iaddr++, patword);
-    patword=setBit(SIGNAL_CHSclk,patword);
-    writePatternWord(iaddr++, patword);
-    patword=clearBit(SIGNAL_CHSclk,patword);
-    writePatternWord(iaddr++, patword);
-  }
 
-  patword=clearBit(SIGNAL_serialIN,patword);
+    int error = 0;
-  for (int i=0; i<2; i++)
+    if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
-      writePatternWord(iaddr++, patword);
+        LOG(logERROR,
-  patword=setBit(SIGNAL_STO,patword);
+            ("Could not set to trimming clock in order to change CSR\n"));
-  for (int i=0; i<5; i++)
+        return FAIL;
-      writePatternWord(iaddr++, patword);
+    }
-  patword=clearBit(SIGNAL_STO,patword);
+    pat = setChipStatusRegisterPattern(csr);
-  for (int i=0; i<5; i++)
-    writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_STATLOAD,patword);
-  for (int i=0; i<5; i++)
-    writePatternWord(iaddr++, patword);
 
-  if (iaddr >= MAX_PATTERN_LENGTH) {
+    if (pat) {
-    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+        error |= loadPattern(pat);
-		   iaddr, MAX_PATTERN_LENGTH));
+        if (!error)
-    error = 1;
+            startPattern();
-  }
+        free(pat);
-  // set pattern wait address
+    } else {
-  for (int i = 0; i <= 2; i++)
+        error = 1;
-    setPatternWaitAddress(i, MAX_PATTERN_LENGTH - 1);
+    }
-  
-  // pattern loop
-  for (int i = 0; i <= 2; i++) {
-    int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
-    setPatternLoop(i, &stop, &stop, &nloop);
-  }
-  
-  // pattern limits
-  {
-    int start = 0, nloop = 0;
-    setPatternLoop(-1, &start, &iaddr, &nloop);
-  }
-  // send pattern to the chips
-  startPattern();
-  
-  if (error != 0) {
-    return FAIL;
-  }
-  
-  return OK;
 
+    if (!error) {
+        LOG(logINFO, ("CSR is now: 0x%x\n", csr));
+    }
+
+    if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
+        LOG(logERROR,
+            ("Could not set to previous run clock after changing CSR\n"));
+        return FAIL;
+    }
+    return OK;
+}
+
+int setGainCaps(int caps){
+    // Update only gain caps, leave the rest of the CSR unchanged
+    int csr = getChipStatusRegister();
+    csr &= ~GAIN_MASK;
+
+    caps = gainCapsToCsr(caps);
+    // caps &= GAIN_MASK;
+    csr |= caps;
+    return setChipStatusRegister(csr);
+}
+
+int getGainCaps(){
+    int csr = getChipStatusRegister();
+    int caps = csrToGainCaps(csr);
+    return caps; 
 }

slsDetectorServers/mythen3DetectorServer/slsDetectorServer_defs.h

@@ -1,7 +1,7 @@
 #pragma once
 #include "sls/sls_detector_defs.h"
 
-#define REQRD_FRMWRE_VRSN (0x200925)
+#define REQRD_FRMWRE_VRSN (0x210201)
 #define KERNEL_DATE_VRSN  "Wed May 20 13:58:38 CEST 2020"
 #define ID_FILE           "detid_mythen3.txt"
 
@@ -47,7 +47,7 @@
 #define DEFAULT_HIGHGAIN_VRPREAMP (1300)
 #define DEFAULT_STANDARD_VRSHAPER (1280)
 #define DEFAULT_FAST_VRSHAPER     (1500)
-#define DEFAULT_HIGHGAIN_VRSHAPER (900)
+#define DEFAULT_HIGHGAIN_VRSHAPER (1100)
 
 #define DEFAULT_READOUT_C0 (10) //(100000000) // rdo_clk, 100 MHz
 #define DEFAULT_READOUT_C1 (10) //(100000000) // smp sample clk (x2), 100 MHz
@@ -158,47 +158,3 @@ typedef struct udp_header_struct {
 #define UDP_IP_HEADER_LENGTH_BYTES (28)
 #define PACKETS_PER_FRAME_10G      (2)
 #define PACKETS_PER_FRAME_1G       (20)
-
-/** Signal Definitions */
-#define SIGNAL_TBLoad_1    (0)
-#define SIGNAL_TBLoad_2    (1)
-#define SIGNAL_TBLoad_3    (2)
-#define SIGNAL_TBLoad_4    (3)
-#define SIGNAL_TBLoad_5    (4)
-#define SIGNAL_TBLoad_6    (5)
-#define SIGNAL_TBLoad_7    (6)
-#define SIGNAL_TBLoad_8    (7)
-#define SIGNAL_TBLoad_9    (8)
-#define SIGNAL_TBLoad_10   (9)
-#define SIGNAL_AnaMode     (10)
-#define SIGNAL_CHSserialIN (11)
-#define SIGNAL_READOUT     (12)
-#define SIGNAL_pulse       (13)
-#define SIGNAL_EN1         (14)
-#define SIGNAL_EN2         (15)
-#define SIGNAL_EN3         (16)
-#define SIGNAL_clk         (17)
-#define SIGNAL_SRmode      (18)
-#define SIGNAL_serialIN    (19)
-#define SIGNAL_STO         (20)
-#define SIGNAL_STATLOAD    (21)
-#define SIGNAL_resStorage  (22)
-#define SIGNAL_resCounter  (23)
-#define SIGNAL_CHSclk      (24)
-#define SIGNAL_exposing    (25)
-
-//CHIP STARTUS REGISTER BITS
-#define CSR_spypads  0
-#define CSR_invpol  4
-#define CSR_dpulse  5
-#define CSR_interp  6
-#define CSR_C10pre  7 //#default
-#define CSR_pumprobe  8
-#define CSR_apulse  9
-#define CSR_C15sh  10 
-#define CSR_C30sh  11 //#default
-#define CSR_C50sh  12
-#define CSR_C225ACsh  13 // Connects 225fF SHAPER AC cap (1: 225 to shaper, 225 to GND. 0: 450 to shaper) 
-#define CSR_C15pre  14 
-
-#define CSR_default  (1<<CSR_C10pre )|(1<< CSR_C30sh)

slsDetectorServers/slsDetectorServer/include/loadPattern.h

@@ -0,0 +1,6 @@
+#ifndef LOADPATTERN_H
+#define LOADPATTERN_H
+#include "Pattern.h"
+
+int loadPattern(patternParameters *pat);
+#endif

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -25,6 +25,10 @@
 #include "blackfin.h"
 #endif
 
+#if defined(MYTHEN3D) 
+#include "mythen3.h"
+#endif
+
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -352,6 +356,11 @@ void setTiming(enum timingMode arg);
 enum timingMode getTiming();
 #ifdef MYTHEN3D
 void setInitialExtSignals();
+int isMaster();
+int setGainCaps(int caps);
+int getGainCaps();
+int setChipStatusRegister(int csr);
+int setDACS(int* dacs);
 #endif
 #if defined(GOTTHARDD) || defined(MYTHEN3D)
 void setExtSignal(int signalIndex, enum externalSignalFlag mode);

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -245,4 +245,8 @@ int set_default_dacs(int);
 int is_virtual(int);
 int get_pattern(int);
 int load_default_pattern(int);
-int get_all_threshold_energy(int);
+int get_all_threshold_energy(int);
+int get_master(int);
+int get_csr();
+int set_gain_caps(int);
+int get_gain_caps(int);

slsDetectorServers/slsDetectorServer/src/loadPattern.c

@@ -0,0 +1,105 @@
+#include "readDefaultPattern.h"
+#include "loadPattern.h"
+#include "clogger.h"
+#include "common.h"
+#include "sls/ansi.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorServer_defs.h"
+
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D)
+#include "Pattern.h"
+#endif
+
+#include <string.h>
+#include <unistd.h>
+
+extern char initErrorMessage[MAX_STR_LENGTH];
+
+#ifndef MYTHEN3D
+extern uint64_t writePatternIOControl(uint64_t word);
+#endif
+extern uint64_t writePatternWord(int addr, uint64_t word);
+extern int setPatternWaitAddress(int level, int addr);
+extern uint64_t setPatternWaitTime(int level, uint64_t t);
+extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
+                           int *nLoop);
+
+int loadPattern(patternParameters *pat) {
+
+  int ret=OK;
+
+  for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
+    if ((i % 10 == 0) && pat->word[i] != 0) {
+      LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
+		    i, (long long int)pat->word[i]));
+    }
+    writePatternWord(i, pat->word[i]);
+  }
+#ifndef MYTHEN3D 
+   if (ret == OK) { 
+     uint64_t retval64 = writePatternIOControl(pat->ioctrl); 
+     //validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX); 
+   } 
+#endif 
+        if (ret == OK) {
+            int numLoops = -1;
+            int retval0 = pat->limits[0];
+            int retval1 = pat->limits[1];
+            setPatternLoop(-1, &retval0, &retval1, &numLoops);
+            //validate(pat->limits[0], retval0,
+	    // "set pattern Limits start address", HEX);
+	//validate(pat->limits[1], retval1,
+	    //       "set pattern Limits start address", HEX);
+        }
+	uint64_t retval64;
+        if (ret == OK) {
+            for (int i = 0; i <= 2; ++i) {
+                char msg[128];
+                int retval0 = -1, retval1 = -1, numLoops = -1;
+
+                // patloop
+                retval0 = pat->loop[i * 2 + 0];
+                retval1 = pat->loop[i * 2 + 1];
+                numLoops = pat->nloop[i];
+                setPatternLoop(i, &retval0, &retval1, &numLoops);
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d start address", i);
+                //validate(pat->loop[i * 2 + 0], retval0, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d stop address", i);
+                //validate(pat->loop[i * 2 + 1], retval1, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d num loops", i);
+                //validate(pat->nloop[i], numLoops, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                // patwait
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d wait address", i);
+                retval0 = setPatternWaitAddress(i, pat->wait[i]);
+                //validate(pat->wait[i], retval0, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+
+                // patwaittime
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d wait time", i);
+                retval64 = setPatternWaitTime(i, pat->waittime[i]);
+                //validate64(pat->waittime[i], retval64, msg, HEX);
+                if (retval64 == FAIL) {
+                    break;
+                }
+	    }
+	}
+	return ret;
+}
+
+

slsDetectorServers/slsDetectorServer/src/readDefaultPattern.c

@@ -1,4 +1,5 @@
 #include "readDefaultPattern.h"
+#include "loadPattern.h"
 #include "clogger.h"
 #include "common.h"
 #include "sls/ansi.h"

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -368,6 +368,10 @@ void function_table() {
     flist[F_GET_PATTERN] = &get_pattern;
     flist[F_LOAD_DEFAULT_PATTERN] = &load_default_pattern;
     flist[F_GET_ALL_THRESHOLD_ENERGY] = &get_all_threshold_energy;
+    flist[F_GET_MASTER] = &get_master;
+    flist[F_GET_CSR] = &get_csr;
+    flist[F_SET_GAIN_CAPS] = &set_gain_caps;
+    flist[F_GET_GAIN_CAPS] = &get_gain_caps;
 
     // check
     if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@@ -638,7 +642,9 @@ int set_timing_mode(int file_des) {
     }
     // get
     retval = getTiming();
+    #ifndef MYTHEN3D
     validate((int)arg, (int)retval, "set timing mode", DEC);
+    #endif
     LOG(logDEBUG1, ("Timing Mode: %d\n", retval));
 
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@@ -1544,18 +1550,11 @@ int set_module(int file_des) {
     // only set
     else if (Server_VerifyLock() == OK) {
         // check index
+
+#if !(defined(EIGERD) || defined(MYTHEN3D))
+//TODO! Check if this is used for any detector
         switch (module.reg) {
-#ifdef EIGERD
+#ifdef JUNGFRAUD
-        case STANDARD:
-        case HIGHGAIN:
-        case LOWGAIN:
-        case VERYHIGHGAIN:
-        case VERYLOWGAIN:
-#elif MYTHEN3D
-        case STANDARD:
-        case FAST:
-        case HIGHGAIN:
-#elif JUNGFRAUD
         case DYNAMICGAIN:
         case DYNAMICHG0:
         case FIXGAIN1:
@@ -1574,10 +1573,12 @@ int set_module(int file_des) {
             modeNotImplemented("Settings", (int)module.reg);
             break;
         }
-
+#endif
         ret = setModule(module, mess);
         enum detectorSettings retval = getSettings();
+#if !(defined(EIGERD) || defined(MYTHEN3D))
         validate(module.reg, (int)retval, "set module (settings)", DEC);
+#endif
         LOG(logDEBUG1, ("Settings: %d\n", retval));
     }
     free(myChan);
@@ -7575,18 +7576,22 @@ int set_pattern(int file_des) {
 
     patternParameters *pat = malloc(sizeof(patternParameters));
     memset(pat, 0, sizeof(patternParameters));
-
+      // ignoring endianness for eiger
-    // ignoring endianness for eiger
     if (receiveData(file_des, pat, sizeof(patternParameters), INT32) < 0) {
         if (pat != NULL)
             free(pat);
         return printSocketReadError();
     }
-
+ 
     if (Server_VerifyLock() == OK) {
         LOG(logINFO, ("Setting Pattern from structure\n"));
         LOG(logINFO,
-            ("Setting Pattern Word (printing every 10 words that are not 0\n"));
+            ("Setting Pattern Word (printing every 10 words that are not 0\n"));   
+	/****************************************************************************************************************/
+	/* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A SEPARATE FUNCTION WHICH COULD BE REUSED*/
+	/* added loadPattern.c/h - the same func could be reused also in readDefaultPattern                                  */
+	/***************************************************************************************************************/
+
         for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
             if ((i % 10 == 0) && pat->word[i] != 0) {
                 LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
@@ -7659,6 +7664,7 @@ int set_pattern(int file_des) {
                 }
             }
         }
+	/******* DOWN TO HERE ***********/
     }
     if (pat != NULL)
         free(pat);
@@ -8365,3 +8371,78 @@ int get_all_threshold_energy(int file_des) {
 #endif
     return Server_SendResult(file_des, INT32, retvals, sizeof(retvals));
 }
+
+int get_master(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting master\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    retval = isMaster();
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int get_csr(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting csr\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    retval = getChipStatusRegister();
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_gain_caps(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting gain caps to: %u\n", arg));
+
+    int retval = -1;
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    if (Server_VerifyLock() == OK) {
+        setGainCaps(arg);
+        retval = getChipStatusRegister(); //TODO! fix 
+        LOG(logDEBUG1, ("gain caps retval: %u\n", retval));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int get_gain_caps(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    // int arg = 0;
+
+    // if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+    //     return printSocketReadError();
+    LOG(logINFO, ("Getting gain caps\n"));
+
+    int retval = -1;
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    if (Server_VerifyLock() == OK) {
+        retval = getGainCaps();
+        LOG(logDEBUG1, ("Gain caps: %u\n", retval));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}

slsDetectorSoftware/include/sls/Detector.h

@@ -1305,6 +1305,17 @@ class Detector {
     /** [Mythen3] gate delay for all gates in auto or trigger timing mode
      * (internal gating). Gate index: 0-2, -1 for all */
     Result<std::array<ns, 3>> getGateDelayForAllGates(Positions pos = {}) const;
+
+    Result<bool> getMaster(Positions pos = {}) const;
+
+
+    //TODO! check if we really want to expose this !!!!!
+    Result<int> getChipStatusRegister(Positions pos = {}) const;
+
+    void setGainCaps(int caps, Positions pos = {});
+
+    Result<int> getGainCaps(Positions pos = {});
+
     ///@{
 
     /** @name CTB / Moench Specific */

slsDetectorSoftware/src/CmdParser.cpp

@@ -55,6 +55,12 @@ void CmdParser::Parse(const std::string &s) {
         command_ = arguments_[0];
         arguments_.erase(begin(arguments_));
     }
+    //allow comma sep
+    for (auto& arg : arguments_){
+        if (arg.back() == ',')
+            arg.pop_back();
+    }
+
     DecodeIdAndPosition(command_.c_str());
 }
 

slsDetectorSoftware/src/CmdProxy.cpp

@@ -54,7 +54,7 @@ bool CmdProxy::ReplaceIfDepreciated(std::string &command) {
     if (d_it != depreciated_functions.end()) {
         LOG(logWARNING)
             << command
-            << " is depreciated and will be removed. Please migrate to: "
+            << " is deprecated and will be removed. Please migrate to: "
             << d_it->second;
         // insert old command into arguments (for dacs)
         if (d_it->second == "dac") {
@@ -1981,6 +1981,43 @@ std::string CmdProxy::GateDelay(int action) {
     return os.str();
 }
 
+
+std::string CmdProxy::GainCaps(int action){
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == defs::HELP_ACTION) {
+        os << "[cap1, cap2, ...]\n\t[Mythen3] gain, options: C10pre, C15sh, C30sh, C50sh, C225ACsh, C15pre"
+           << '\n';
+    } else if (action == defs::GET_ACTION) {
+        if (!args.empty())
+            WrongNumberOfParameters(0);
+
+        auto tmp = det->getGainCaps();
+        sls::Result<defs::M3_GainCaps> csr;
+        for (auto val : tmp){
+            if (val)
+                csr.push_back(static_cast<defs::M3_GainCaps>(val));
+        }
+            
+        os << OutString(csr) << '\n';
+    } else if (action == defs::PUT_ACTION) {
+        if (args.size() < 1) {
+            WrongNumberOfParameters(1);
+        }
+        int caps = 0;
+        for (const auto& arg:args){
+            if (arg != "0")
+                caps |= sls::StringTo<defs::M3_GainCaps>(arg);
+        }
+            
+        det->setGainCaps(caps);
+        os << OutString(args) << '\n';
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
 /* CTB / Moench Specific */
 
 std::string CmdProxy::Samples(int action) {

slsDetectorSoftware/src/CmdProxy.h

@@ -571,19 +571,6 @@ class CmdProxy {
         return ToString(value, unit);
     }
 
-    // inline unsigned int stoiHex(const std::string& s) {
-    //     unsigned long lresult = stoul(s, nullptr, 16);
-    //     unsigned int result = lresult;
-    //     if (result != lresult) {
-    //         throw std::out_of_range("cannot convert to unsigned int");
-    //     }
-    //     return result;
-    // }
-
-    // inline unsigned long int stoulHex(const std::string& s) {
-    //     unsigned long result = stoul(s, nullptr, 16);
-    //     return result;
-    // }
 
     using FunctionMap = std::map<std::string, std::string (CmdProxy::*)(int)>;
     using StringMap = std::map<std::string, std::string>;
@@ -970,6 +957,7 @@ class CmdProxy {
         {"gatedelay1", &CmdProxy::GateDelay},
         {"gatedelay2", &CmdProxy::GateDelay},
         {"gatedelay3", &CmdProxy::GateDelay},
+        {"gaincaps", &CmdProxy::GainCaps},
 
         /* CTB/ Moench Specific */
         {"samples", &CmdProxy::Samples},
@@ -1137,6 +1125,7 @@ class CmdProxy {
     /* Mythen3 Specific */
     std::string Counters(int action);
     std::string GateDelay(int action);
+    std::string GainCaps(int action);
     /* CTB/ Moench Specific */
     std::string Samples(int action);
     /* CTB Specific */

slsDetectorSoftware/src/Detector.cpp

@@ -674,7 +674,23 @@ void Detector::startReceiver() { pimpl->Parallel(&Module::startReceiver, {}); }
 void Detector::stopReceiver() { pimpl->Parallel(&Module::stopReceiver, {}); }
 
 void Detector::startDetector() {
-    pimpl->Parallel(&Module::startAcquisition, {});
+    auto detector_type = getDetectorType().squash();
+    if (detector_type == defs::MYTHEN3 && size() > 1){
+        auto is_master = getMaster();
+        std::vector<int> master;
+        std::vector<int> slaves;
+        for(int i=0; i<size(); ++i){
+            if (is_master[i])
+                master.push_back(i);
+            else
+                slaves.push_back(i);
+        }
+        pimpl->Parallel(&Module::startAcquisition, slaves);
+        pimpl->Parallel(&Module::startAcquisition, master);
+    }else{
+        pimpl->Parallel(&Module::startAcquisition, {});
+    }
+    
 }
 
 void Detector::startDetectorReadout() {
@@ -717,6 +733,9 @@ Result<defs::scanParameters> Detector::getScan(Positions pos) const {
 }
 
 void Detector::setScan(const defs::scanParameters t) {
+    if(getDetectorType().squash() == defs::MYTHEN3 && size()>1 && t.enable != 0){
+        throw DetectorError("Scan is only allowed for single module Mythen 3 because of synchronization");
+    }
     pimpl->Parallel(&Module::setScan, {}, t);
 }
 
@@ -1592,6 +1611,23 @@ Detector::getGateDelayForAllGates(Positions pos) const {
     return pimpl->Parallel(&Module::getGateDelayForAllGates, pos);
 }
 
+Result<bool> Detector::getMaster(Positions pos) const{
+    return pimpl->Parallel(&Module::isMaster, pos);
+}
+
+Result<int> Detector::getChipStatusRegister(Positions pos) const{
+    return pimpl->Parallel(&Module::getChipStatusRegister, pos);
+}
+
+void Detector::setGainCaps(int caps, Positions pos){
+    return pimpl->Parallel(&Module::setGainCaps, pos, caps);
+}
+
+Result<int> Detector::getGainCaps(Positions pos){
+    return pimpl->Parallel(&Module::getGainCaps, pos);
+}
+
+
 // CTB/ Moench Specific
 
 Result<int> Detector::getNumberOfAnalogSamples(Positions pos) const {

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -1056,11 +1056,15 @@ void DetectorImpl::registerDataCallback(void (*userCallback)(detectorData *,
 }
 
 int DetectorImpl::acquire() {
+
     // ensure acquire isnt started multiple times by same client
     if (!isAcquireReady()) {
         return FAIL;
     }
 
+    // We need this to handle Mythen3 synchronization
+    auto detector_type = Parallel(&Module::getDetectorType, {}).squash();
+
     try {
         struct timespec begin, end;
         clock_gettime(CLOCK_REALTIME, &begin);
@@ -1088,7 +1092,25 @@ int DetectorImpl::acquire() {
 
         // start and read all
         try {
-            Parallel(&Module::startAndReadAll, {});
+            if(detector_type == defs::MYTHEN3 && detectors.size() > 1){
+                //Multi module mythen
+                std::vector<int> master;
+                std::vector<int> slaves;
+                auto is_master = Parallel(&Module::isMaster, {});
+                slaves.reserve(detectors.size()-1); //check this one!!
+                for (size_t i = 0; i<detectors.size(); ++i){
+                    if(is_master[i])
+                        master.push_back(i);
+                    else
+                        slaves.push_back(i);
+                }
+                Parallel(&Module::startAcquisition, slaves);
+                Parallel(&Module::startAndReadAll, master);
+            }else{
+                //Normal acquire
+                Parallel(&Module::startAndReadAll, {});
+            }
+            
         } catch (...) {
             if (receiver)
                 Parallel(&Module::stopReceiver, {});

slsDetectorSoftware/src/Module.cpp

@@ -317,9 +317,9 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
         myMod.dacs[M_VTRIM] = sum / counters.size();
 
         // copy vth1, vth2 and vth3 from the correct threshold mods
-        myMod.dacs[VTH1] = myMods[0].dacs[VTH1];
+        myMod.dacs[M_VTH1] = myMods[0].dacs[M_VTH1];
-        myMod.dacs[VTH2] = myMods[1].dacs[VTH2];
+        myMod.dacs[M_VTH2] = myMods[1].dacs[M_VTH2];
-        myMod.dacs[VTH3] = myMods[2].dacs[VTH3];
+        myMod.dacs[M_VTH3] = myMods[2].dacs[M_VTH3];
 
         // check if dacs are different
         for (size_t j = 0; j < 16; ++j) {
@@ -351,6 +351,38 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
     myMod.reg = isettings;
     std::copy(e_eV.begin(), e_eV.end(), myMod.eV);
     LOG(logDEBUG) << "ev:" << ToString(myMod.eV);
+
+    //check for trimbits that are out of range 
+    bool out_of_range = false;
+    for(int i = 0; i!=myMod.nchan; ++i){
+        if (myMod.chanregs[i]<0){
+            myMod.chanregs[i] = 0;
+            out_of_range = true;
+        }else if(myMod.chanregs[i]>63){
+            myMod.chanregs[i]=63;
+            out_of_range = true;
+        }
+    }
+    if (out_of_range){
+            LOG(logWARNING) << "Some trimbits were out of range after interpolation, these have been replaced with 0 or 63.";
+    }
+
+    //check dacs
+    out_of_range = false;
+    for (auto dac : {M_VTRIM,M_VTH1,M_VTH2, M_VTH3}){
+        if (myMod.dacs[dac] < 600){
+            myMod.dacs[dac] = 600;
+            out_of_range = true;
+        }else if(myMod.dacs[dac] > 2400){
+            myMod.dacs[dac] = 2400;
+            out_of_range = true;
+        }
+    }
+    if (out_of_range){
+            LOG(logWARNING) << "Some dacs were out of range after interpolation, these have been replaced with 600 or 2400.";
+    }
+
+
     setModule(myMod, trimbits);
     if (getSettings() != isettings) {
         throw RuntimeError("setThresholdEnergyAndSettings: Could not set "
@@ -1962,6 +1994,22 @@ std::array<time::ns, 3> Module::getGateDelayForAllGates() const {
     return sendToDetector<std::array<time::ns, 3>>(F_GET_GATE_DELAY_ALL_GATES);
 }
 
+bool Module::isMaster() const{
+    return sendToDetector<int>(F_GET_MASTER);
+}
+
+int Module::getChipStatusRegister() const{
+    return sendToDetector<int>(F_GET_CSR);
+}
+
+void Module::setGainCaps(int caps){
+    sendToDetector<int>(F_SET_GAIN_CAPS, caps);
+}
+
+int Module::getGainCaps(){
+    return sendToDetector<int>(F_GET_GAIN_CAPS);
+}
+
 // CTB / Moench Specific
 int Module::getNumberOfAnalogSamples() const {
     return sendToDetector<int>(F_GET_NUM_ANALOG_SAMPLES);
@@ -3159,6 +3207,9 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
         throw RuntimeError("Could not open settings file: " + fname);
     }
 
+    auto file_size = getFileSize(infile);
+
+
     // eiger
     if (shm()->myDetectorType == EIGER) {
         infile.read(reinterpret_cast<char *>(myMod.dacs),
@@ -3184,6 +3235,16 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
 
     // mythen3 (dacs, trimbits)
     else if (shm()->myDetectorType == MYTHEN3) {
+        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 +
+                               " differs from the expected size, " +
+                               std::to_string(file_size) + " instead of " +
+                               std::to_string(expected_size) + " bytes");
+        }
+        infile.read(reinterpret_cast<char *>(&myMod.reg),
+                    sizeof(myMod.reg));
         infile.read(reinterpret_cast<char *>(myMod.dacs),
                     sizeof(int) * (myMod.ndac));
         for (int i = 0; i < myMod.ndac; ++i) {

slsDetectorSoftware/src/Module.h

@@ -425,6 +425,10 @@ class Module : public virtual slsDetectorDefs {
     int64_t getGateDelay(int gateIndex) const;
     void setGateDelay(int gateIndex, int64_t value);
     std::array<time::ns, 3> getGateDelayForAllGates() const;
+    bool isMaster() const;
+    int getChipStatusRegister() const;
+    void setGainCaps(int caps);
+    int getGainCaps();
 
     /**************************************************
      *                                                *

slsSupportLib/CMakeLists.txt

@@ -57,14 +57,12 @@ target_include_directories(slsSupportObject
   PUBLIC
     "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-  PRIVATE
-    ${ZeroMQ_INCLUDE_DIRS}
 )
 
 target_link_libraries(slsSupportObject 
   PUBLIC
     slsProjectOptions 
-    ${ZeroMQ_LIBRARIES}
+    libzmq
     rapidjson
   PRIVATE
     slsProjectWarnings     
@@ -76,7 +74,6 @@ endif(SLS_USE_TESTS)
 
 # Add shared library version of the support lib
 add_library(slsSupportShared SHARED $<TARGET_OBJECTS:slsSupportObject>)
-
 target_link_libraries(slsSupportShared PUBLIC slsSupportObject)
 
 set_target_properties(slsSupportShared PROPERTIES
@@ -108,3 +105,4 @@ install(TARGETS slsSupportShared slsSupportStatic slsSupportObject
     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sls
 )
 
+

slsSupportLib/include/sls/ToString.h

@@ -36,6 +36,7 @@ std::string ToString(const defs::dacIndex s);
 std::string ToString(const std::vector<defs::dacIndex> &vec);
 std::string ToString(const defs::burstMode s);
 std::string ToString(const defs::timingSourceType s);
+std::string ToString(const defs::M3_GainCaps s);
 
 std::string ToString(const slsDetectorDefs::xy &coord);
 std::ostream &operator<<(std::ostream &os, const slsDetectorDefs::xy &coord);
@@ -297,6 +298,7 @@ template <> defs::readoutMode StringTo(const std::string &s);
 template <> defs::dacIndex StringTo(const std::string &s);
 template <> defs::burstMode StringTo(const std::string &s);
 template <> defs::timingSourceType StringTo(const std::string &s);
+template <> defs::M3_GainCaps StringTo(const std::string &s);
 
 template <> uint32_t StringTo(const std::string &s);
 template <> uint64_t StringTo(const std::string &s);

slsSupportLib/include/sls/file_utils.h

@@ -48,3 +48,7 @@ int writeDataFile(std::string fname, int nch, short int *data);
 
 // mkdir -p path implemented by recursive calls
 void mkdir_p(const std::string &path, std::string dir = "");
+
+namespace sls {
+int getFileSize(std::ifstream &ifs);
+}

slsSupportLib/include/sls/sls_detector_defs.h

@@ -394,6 +394,16 @@ typedef struct {
      */
     enum timingSourceType { TIMING_INTERNAL, TIMING_EXTERNAL };
 
+    //gain caps Mythen3
+    enum M3_GainCaps {
+        M3_C10pre= 1<<7, 
+        M3_C15sh = 1<<10, 
+        M3_C30sh = 1<<11,
+        M3_C50sh = 1<<12,
+        M3_C225ACsh = 1<<13,
+        M3_C15pre = 1<<14, 
+    };
+
 #ifdef __cplusplus
 
     /** scan structure */
@@ -625,6 +635,10 @@ typedef struct {
 #endif
 
 #ifdef __cplusplus
+
+
+
+
 // TODO! discuss this
 #include <vector> //hmm... but currently no way around
 namespace sls {

slsSupportLib/include/sls/sls_detector_funcs.h

@@ -220,6 +220,10 @@ enum detFuncs {
     F_GET_PATTERN,
     F_LOAD_DEFAULT_PATTERN,
     F_GET_ALL_THRESHOLD_ENERGY,
+    F_GET_MASTER,
+    F_GET_CSR,
+    F_SET_GAIN_CAPS,
+    F_GET_GAIN_CAPS,
 
     NUM_DET_FUNCTIONS,
     RECEIVER_ENUM_START = 256, /**< detector function should not exceed this
@@ -546,6 +550,7 @@ const char* getFunctionNameFromEnum(enum detFuncs func) {
     case F_GET_PATTERN:                     return "F_GET_PATTERN";
     case F_LOAD_DEFAULT_PATTERN:            return "F_LOAD_DEFAULT_PATTERN";
     case F_GET_ALL_THRESHOLD_ENERGY:        return "F_GET_ALL_THRESHOLD_ENERGY";
+    case F_GET_MASTER:                      return "F_GET_MASTER";
 
     case NUM_DET_FUNCTIONS:              	return "NUM_DET_FUNCTIONS";
     case RECEIVER_ENUM_START:				return "RECEIVER_ENUM_START";

slsSupportLib/include/sls/versionAPI.h

@@ -1,12 +1,12 @@
 /** API versions */
 #define GITBRANCH    "developer"
-#define APILIB 0x201119
+#define APICTB 0x210225
-#define APIRECEIVER 0x201119
+#define APIGOTTHARD 0x210225
-#define APIGUI 0x201119
+#define APIGOTTHARD2 0x210225
-#define APICTB 0x201214
+#define APIJUNGFRAU 0x210225
-#define APIGOTTHARD 0x201214
+#define APIMOENCH 0x210225
-#define APIGOTTHARD2 0x201214
+#define APIEIGER 0x210225
-#define APIJUNGFRAU 0x201214
+#define APIMYTHEN3 0x210225
-#define APIMOENCH 0x201214
+#define APILIB 0x210225
-#define APIEIGER 0x201214
+#define APIRECEIVER 0x210225
-#define APIMYTHEN3 0x201214
+#define APIGUI 0x210225

slsSupportLib/src/ToString.cpp

@@ -859,6 +859,44 @@ template <> defs::timingSourceType StringTo(const std::string &s) {
     throw sls::RuntimeError("Unknown timing source type " + s);
 }
 
+template <> defs::M3_GainCaps StringTo(const std::string &s){
+    if (s == "C10pre")
+        return defs::M3_C10pre;
+    if (s == "C15sh")
+        return defs::M3_C15sh;
+    if (s == "C30sh")
+        return defs::M3_C30sh;
+    if (s == "C50sh")
+        return defs::M3_C50sh;
+    if (s == "C225ACsh")
+        return defs::M3_C225ACsh;
+    if (s == "C15pre")
+        return defs::M3_C15pre;
+    throw sls::RuntimeError("Unknown gain cap " + s);
+    
+}
+
+
+std::string ToString(defs::M3_GainCaps s){
+    std::ostringstream os; 
+    if (s & defs::M3_C10pre)
+        os << "C10pre, ";
+    if (s & defs::M3_C15sh)
+        os << "C15sh, ";
+    if (s & defs::M3_C30sh)
+        os << "C30sh, ";
+    if (s & defs::M3_C50sh)
+        os << "C50sh, ";
+    if (s & defs::M3_C225ACsh)
+        os << "C225ACsh, ";
+    if (s & defs::M3_C15pre)
+        os << "C15pre, ";
+    auto rs = os.str();
+    rs.erase(rs.end()-2);
+    return rs;
+    
+}
+
 template <> uint32_t StringTo(const std::string &s) {
     int base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoul(s, nullptr, base);

slsSupportLib/src/file_utils.cpp

@@ -3,6 +3,7 @@
 #include "sls/sls_detector_exceptions.h"
 
 #include <errno.h>
+#include <ios>
 #include <iostream>
 #include <sstream>
 #include <sys/stat.h>
@@ -92,3 +93,13 @@ void mkdir_p(const std::string &path, std::string dir) {
     if (i + 1 < path.length())
         mkdir_p(path.substr(i + 1), dir);
 }
+
+namespace sls {
+int getFileSize(std::ifstream &ifs) {
+    auto current_pos = ifs.tellg();
+    ifs.seekg(0, std::ios::end);
+    int file_size = ifs.tellg();
+    ifs.seekg(current_pos);
+    return file_size;
+}
+} // namespace sls

slsSupportLib/tests/CMakeLists.txt

@@ -1,5 +1,6 @@
 target_sources(tests PRIVATE 
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-bit_utils.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-file_utils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-container_utils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-network_utils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-string_utils.cpp

slsSupportLib/tests/test-file_utils.cpp

@@ -0,0 +1,28 @@
+#include "catch.hpp"
+#include "sls/file_utils.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <iostream>
+#include <vector>
+
+TEST_CASE("Get size of empty file") {
+    char fname[] = "temfile_XXXXXX";
+    int fh = mkstemp(fname);
+    std::ifstream ifs(fname);
+    auto size = sls::getFileSize(ifs);
+    REQUIRE(size == 0);
+}
+
+TEST_CASE("Get size of file with data") {
+    constexpr size_t n_bytes = 137;
+    std::vector<char> data(n_bytes);
+    char fname[] = "temfile_XXXXXX";
+    int fh = mkstemp(fname);
+    write(fh, data.data(), n_bytes);
+
+    std::ifstream ifs(fname);
+    auto size = sls::getFileSize(ifs);
+    REQUIRE(size == n_bytes);
+    REQUIRE(ifs.tellg() == 0); //getting size resets pos!
+}
+

tests/CMakeLists.txt

@@ -18,22 +18,24 @@ set_target_properties(testserver PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
     
 add_executable(tests ${SLS_TEST_SOURCES})
-target_link_libraries(tests 
+target_link_libraries(tests
-    slsProjectOptions
+    PUBLIC 
-    slsProjectWarnings
+      slsProjectOptions
-    slsSupportShared
+      slsSupportShared
-    pthread
+      pthread
-    rt
+      rt
+    PRIVATE
+      slsProjectWarnings
 )  
 
 if (SLS_USE_TEXTCLIENT)
-    target_link_libraries(tests
+    target_link_libraries(tests PUBLIC
         slsDetectorShared
     )
 endif (SLS_USE_TEXTCLIENT)
 
 if (SLS_USE_RECEIVER)
-    target_link_libraries(tests
+    target_link_libraries(tests PUBLIC
         slsReceiverShared
     )
 endif (SLS_USE_RECEIVER)