M3: fixed gain bits with negative polarity

* 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.

The new server has been compiled

Co-authored-by: lopez_c <carlos.lopez-cuenca@psi.ch>

CMakeLists.txt

@@ -167,7 +167,7 @@ if (NOT TARGET libzmq)
             HINTS ${ZeroMQ_DIR}
         )
     else()
-        find_package(ZeroMQ 4)
+        find_package(ZeroMQ 4 QUIET)
     endif()
     
 

RELEASE.txt

@@ -1,7 +1,7 @@
-SLS Detector Package 5.1.0 released on 22.03.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.0.1 releases.   
+This document describes the differences between X and Y releases.   
 
 
 
@@ -19,69 +19,21 @@ This document describes the differences between 5.1.0 and 5.0.1 releases.
 1. New Features
 ===============
 
-    Client
+    Setting Mythen3 gain from command line
-    ------
 
-    1. Added settings and threshold features for Mythen3.
+4. Firmware Requirements
-    2. Internal modification of acquire for Mythen3.
-    3. Added getMaster for Mythen3
-    4. Mythen3, API function to set pattern from memory
-
-
-    Mythen3 server
-    -----------------
-
-    1. Setting timing to auto, sets timing to trigger for slaves
-    
-
-2. 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
-
-    3.  Fixed hardcoded path accidentally ending up in the exported CMake package
-
-    Server
-    --------
-
-    1.  Bottom port not mirrored correctly for Eiger quad
-
-
-
-
-
-3. Firmware Requirements
 ========================
     
-    Mythen3: 0x210201
-    Jungfrau: 0x210218 (1.0 pcb)
-              0x200721 (2.0 pcb, not changed)
-
-    Other detectors no updates from 5.0.0
 
 
-
+5. Known Issues
-4. Known Issues
 ===============
 
     No updates from 5.0.0
 
 
 
-5. Download, Documentation & Support
+6. Download, Documentation & Support
 ====================================
 
     Download

python/scripts/compile_servers.py

@@ -49,13 +49,13 @@ args = parser.parse_args()
 
 
 servers = [
-     "eigerDetectorServer",
+#     "eigerDetectorServer",
-     "jungfrauDetectorServer",
+#     "jungfrauDetectorServer",
       "mythen3DetectorServer",
-     "gotthard2DetectorServer",
+#     "gotthard2DetectorServer",
-     "gotthardDetectorServer",
+#     "gotthardDetectorServer",
-     "ctbDetectorServer",
+#     "ctbDetectorServer",
-     "moenchDetectorServer",
+#     "moenchDetectorServer",
 ]
 
 

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/slsdet/enums.py

@@ -15,3 +15,4 @@ readoutMode = _slsdet.slsDetectorDefs.readoutMode
 masterFlags = _slsdet.slsDetectorDefs.masterFlags
 burstMode = _slsdet.slsDetectorDefs.burstMode
 timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+M3_GainCaps = _slsdet.slsDetectorDefs.M3_GainCaps

python/src/detector.cpp

@@ -1136,6 +1136,16 @@ void init_det(py::module &m) {
              (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();
 }

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
@@ -11,6 +12,7 @@ add_executable(mythen3DetectorServer_virtual
     ../slsDetectorServer/src/ALTERA_PLL_CYCLONE10.c   
     ../slsDetectorServer/src/programFpgaNios.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) 
  

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 "
-                "settings %d\n",
-                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);
-        patword = setBit(SIGNAL_resCounter, patword);
-        writePatternWord(iaddr++, patword);
-        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();
+            free(pat);
+        } else
+            error = 1;
     }
-
+    /////////////////////////////////////////////////////////////////
     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;
 }
 
@@ -2780,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++)
-      writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_STO,patword);
-  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) {
-    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++)
-    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;
     }
+    pat = setChipStatusRegisterPattern(csr);
 
+    if (pat) {
+        error |= loadPattern(pat);
+        if (!error)
+            startPattern();
+        free(pat);
+    } else {
+        error = 1;
+    }
+
+    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

@@ -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>
@@ -353,6 +357,10 @@ 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

@@ -247,3 +247,6 @@ int get_pattern(int);
 int load_default_pattern(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

@@ -369,6 +369,9 @@ void function_table() {
     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) {
@@ -1547,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:
@@ -1577,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);
@@ -7578,7 +7576,6 @@ int set_pattern(int file_des) {
 
     patternParameters *pat = malloc(sizeof(patternParameters));
     memset(pat, 0, sizeof(patternParameters));
-
       // ignoring endianness for eiger
     if (receiveData(file_des, pat, sizeof(patternParameters), INT32) < 0) {
         if (pat != NULL)
@@ -7590,6 +7587,11 @@ int set_pattern(int file_des) {
         LOG(logINFO, ("Setting Pattern from structure\n"));
         LOG(logINFO,
             ("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",
@@ -7662,6 +7664,7 @@ int set_pattern(int file_des) {
                 }
             }
         }
+	/******* DOWN TO HERE ***********/
     }
     if (pat != NULL)
         free(pat);
@@ -8383,3 +8386,63 @@ int get_master(int file_des){
 #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

@@ -1308,6 +1308,14 @@ class Detector {
 
     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

@@ -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

@@ -1615,6 +1615,18 @@ 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
 

slsDetectorSoftware/src/Module.cpp

@@ -1998,6 +1998,18 @@ 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);
@@ -3195,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),
@@ -3220,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

@@ -426,6 +426,9 @@ class Module : public virtual slsDetectorDefs {
     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

@@ -10,6 +10,7 @@ set(SOURCES
     src/ZmqSocket.cpp
     src/UdpRxSocket.cpp
     src/sls_detector_exceptions.cpp
+    # src/sls_detector_defs.cpp
 )
 
 # Header files to install as a part of the library

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

@@ -221,6 +221,9 @@ enum detFuncs {
     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

slsSupportLib/include/sls/versionAPI.h

@@ -1,5 +1,5 @@
 /** API versions */
-#define GITBRANCH    "5.1.0"
+#define GITBRANCH    "developer"
 #define APICTB 0x210225
 #define APIGOTTHARD 0x210225
 #define APIGOTTHARD2 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!
+}
+