Merge branch 'g2speed' into fixtests

RELEASE.txt

@@ -164,6 +164,14 @@ This document describes the differences between 6.0.0 and 5.2.0 releases.
         This will only affect shared memory and will not try to change the
         current tcp port of the control/stop server in detector.
 
+    26. [Eiger][Jungfrau][Gotthard2] Speed 
+        Command line: readoutspeed, readoutspeedlist API: getReadoutSpeed/ setReadoutSpeed /
+        getReadoutSpeedList
+        Previous command: speed, setSpeed/ getSpeed
+        [Eiger][Jungfrau] same as before.
+        [Gotthard2] New command to set readout speed. Options: 108, 144 (in MHz)
+        
+
     Detector servers
     ----------------
 

python/slsdet/detector.py

@@ -1645,20 +1645,22 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def speed(self):
+    def readoutspeed(self):
         """
-        [Eiger][Jungfrau] Readout speed of chip. Enum: speedLevel
+        [Eiger][Jungfrau|Gotthard2] Readout speed of chip. Enum: speedLevel
         Note
         -----
-        Options: FULL_SPEED, HALF_SPEED, QUARTER_SPEED \n
+        [Jungfrau] FULL_SPEED, HALF_SPEED (Default), QUARTER_SPEED
-        [Jungfrau] FULL_SPEED option only available from v2.0 boards and with setting number of interfaces to 2.  \n
+        [Eiger] FULL_SPEED (Default), HALF_SPEED, QUARTER_SPEED
+        [Gottthard2] G2_108MHZ (Default), G2_144MHZ
+        [Jungfrau] FULL_SPEED option only available from v2.0 boards and is recommended to set number of interfaces to 2.  \n
         Also overwrites adcphase to recommended default.
         """
-        return element_if_equal(self.getSpeed())
+        return element_if_equal(self.getReadoutSpeed())
 
-    @speed.setter
+    @readoutspeed.setter
-    def speed(self, value):
+    def readoutspeed(self, value):
-        ut.set_using_dict(self.setSpeed, value)
+        ut.set_using_dict(self.setReadoutSpeed, value)
 
     @property
     def rx_jsonpara(self):

python/src/detector.cpp

@@ -254,14 +254,17 @@ void init_det(py::module &m) {
         .def("getTimingModeList",
              (std::vector<defs::timingMode>(Detector::*)() const) &
                  Detector::getTimingModeList)
-        .def("getSpeed",
+        .def("getReadoutSpeed",
              (Result<defs::speedLevel>(Detector::*)(sls::Positions) const) &
-                 Detector::getSpeed,
+                 Detector::getReadoutSpeed,
              py::arg() = Positions{})
-        .def("setSpeed",
+        .def("setReadoutSpeed",
              (void (Detector::*)(defs::speedLevel, sls::Positions)) &
-                 Detector::setSpeed,
+                 Detector::setReadoutSpeed,
              py::arg(), py::arg() = Positions{})
+        .def("getReadoutSpeedList",
+             (std::vector<defs::speedLevel>(Detector::*)() const) &
+                 Detector::getReadoutSpeedList)
         .def("getADCPhase",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getADCPhase,

python/src/enums.cpp

@@ -250,6 +250,8 @@ void init_enums(py::module &m) {
         .value("FULL_SPEED", slsDetectorDefs::speedLevel::FULL_SPEED)
         .value("HALF_SPEED", slsDetectorDefs::speedLevel::HALF_SPEED)
         .value("QUARTER_SPEED", slsDetectorDefs::speedLevel::QUARTER_SPEED)
+        .value("G2_108MHZ", slsDetectorDefs::speedLevel::G2_108MHZ)
+        .value("G2_144MHZ", slsDetectorDefs::speedLevel::G2_144MHZ)
         .export_values();
 
     py::enum_<slsDetectorDefs::burstMode>(Defs, "burstMode")
@@ -269,8 +271,7 @@ void init_enums(py::module &m) {
                slsDetectorDefs::timingSourceType::TIMING_EXTERNAL)
         .export_values();
 
-    py::enum_<slsDetectorDefs::M3_GainCaps>(Defs, "M3_GainCaps",
+    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)
@@ -289,8 +290,10 @@ void init_enums(py::module &m) {
     py::enum_<slsDetectorDefs::streamingInterface>(Defs, "streamingInterface",
                                                    py::arithmetic())
         .value("NONE", slsDetectorDefs::streamingInterface::NONE)
-        .value("LOW_LATENCY_LINK", slsDetectorDefs::streamingInterface::LOW_LATENCY_LINK)
+        .value("LOW_LATENCY_LINK",
-        .value("ETHERNET_10GB", slsDetectorDefs::streamingInterface::ETHERNET_10GB)
+               slsDetectorDefs::streamingInterface::LOW_LATENCY_LINK)
+        .value("ETHERNET_10GB",
+               slsDetectorDefs::streamingInterface::ETHERNET_10GB)
         .value("ALL", slsDetectorDefs::streamingInterface::ALL)
         .export_values()
         .def("__or__",

slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c

@@ -690,7 +690,7 @@ void setupDetector() {
     eiger_photonenergy = DEFAULT_PHOTON_ENERGY;
     setParallelMode(DEFAULT_PARALLEL_MODE);
     setOverFlowMode(DEFAULT_READOUT_OVERFLOW32_MODE);
-    setClockDivider(RUN_CLK, DEFAULT_CLK_SPEED); // clk_devider,half speed
+    setReadoutSpeed(DEFAULT_CLK_SPEED); 
     setIODelay(DEFAULT_IO_DELAY);
     setTiming(DEFAULT_TIMING_MODE);
     setNextFrameNumber(DEFAULT_STARTING_FRAME_NUMBER);
@@ -1712,11 +1712,7 @@ int enableTenGigabitEthernet(int val) {
 }
 
 /* eiger specific - iodelay, pulse, rate, temp, activate, delay nw parameter */
-int setClockDivider(enum CLKINDEX ind, int val) {
+int setReadoutSpeed(int val) {
-    if (ind != RUN_CLK) {
-        LOG(logERROR, ("Unknown clock index: %d\n", ind));
-        return FAIL;
-    }
     if (val >= 0) {
         LOG(logINFO, ("Setting Read out Speed: %d\n", val));
 #ifndef VIRTUAL
@@ -1732,12 +1728,9 @@ int setClockDivider(enum CLKINDEX ind, int val) {
     return OK;
 }
 
-int getClockDivider(enum CLKINDEX ind) {
+int getReadoutSpeed(int* retval) {
-    if (ind != RUN_CLK) {
+    *retval = eiger_readoutspeed;
-        LOG(logERROR, ("Unknown clock index: %d\n", ind));
+    return OK;
-        return FAIL;
-    }
-    return eiger_readoutspeed;
 }
 
 int setIODelay(int val) {

slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c

@@ -506,6 +506,7 @@ void setupDetector() {
     setCurrentSource(DEFAULT_CURRENT_SOURCE);
     setVetoAlgorithm(DEFAULT_ALGORITHM, LOW_LATENCY_LINK);
     setVetoAlgorithm(DEFAULT_ALGORITHM, ETHERNET_10GB);
+    setReadoutSpeed(DEFAULT_READOUT_SPEED);
 }
 
 void setASICDefaults() {
@@ -2083,6 +2084,61 @@ int getVCOFrequency(enum CLKINDEX ind) {
     return ALTERA_PLL_C10_GetVCOFrequency(pllIndex);
 }
 
+int setReadoutSpeed(int val) {
+    switch (val) {
+        case G2_108MHZ:
+            LOG(logINFOBLUE, ("Setting readout speed to 108 MHz\n"));
+            if (setClockDivider(READOUT_C0, SPEED_108_CLKDIV_0) == FAIL) {
+                return FAIL;
+            }
+            if (setClockDivider(READOUT_C1, SPEED_108_CLKDIV_1) == FAIL) {
+                return FAIL;
+            }         
+            if (setPhase(READOUT_C1, SPEED_108_CLKPHASE_DEG_1, 1) == FAIL) {
+                return FAIL;
+            }   
+            break;  
+        case G2_144MHZ:
+            LOG(logINFOBLUE, ("Setting readout speed to 144 MHz\n"));
+            if (setClockDivider(READOUT_C0, SPEED_144_CLKDIV_0) == FAIL) {
+                return FAIL;
+            }
+            if (setClockDivider(READOUT_C1, SPEED_144_CLKDIV_1) == FAIL) {
+                return FAIL;
+            }         
+            if (setPhase(READOUT_C1, SPEED_144_CLKPHASE_DEG_1, 1) == FAIL) {
+                return FAIL;
+            }   
+            break; 
+        default:
+            LOG(logERROR, ("Unknown readout speed %d\n", val));
+            return FAIL;
+    }
+    return OK;
+}
+
+int getReadoutSpeed(int* retval) {
+//TODO ASIC and ADIFreg need to check????
+// clkdiv 2, 3, 4, 5?
+    if (clkDivider[READOUT_C0] == SPEED_108_CLKDIV_0 &&
+     clkDivider[READOUT_C1] == SPEED_108_CLKDIV_1 && 
+     getPhase(READOUT_C1, 1) == SPEED_108_CLKPHASE_DEG_1) {
+        *retval = G2_108MHZ;
+    }
+
+    else if (clkDivider[READOUT_C0] == SPEED_144_CLKDIV_0 &&
+     clkDivider[READOUT_C1] == SPEED_144_CLKDIV_1 && 
+     getPhase(READOUT_C1, 1) == SPEED_144_CLKPHASE_DEG_1) {
+        *retval = G2_144MHZ;
+    }
+    
+    else {
+        *retval = -1;
+        return FAIL;
+    }
+    return OK;
+}
+
 int getMaxClockDivider() { return ALTERA_PLL_C10_GetMaxClockDivider(); }
 
 int setClockDivider(enum CLKINDEX ind, int val) {
@@ -2095,7 +2151,7 @@ int setClockDivider(enum CLKINDEX ind, int val) {
     }
     char *clock_names[] = {CLK_NAMES};
 
-    LOG(logINFO, ("\tSetting %s clock (%d) divider from %d to %d\n",
+    LOG(logINFOBLUE, ("Setting %s clock (%d) divider from %d to %d\n",
                   clock_names[ind], ind, clkDivider[ind], val));
 
     // Remembering old phases in degrees

slsDetectorServers/gotthard2DetectorServer/slsDetectorServer_defs.h

@@ -59,6 +59,14 @@
 #define DEFAULT_SYSTEM_C2  (5)  //(144444448) // sync_clk, 144 MHz
 #define DEFAULT_SYSTEM_C3  (5)  //(144444448) // str_clk, 144 MHz
 
+#define DEFAULT_READOUT_SPEED   (G2_108MHZ)
+#define SPEED_144_CLKDIV_0  (6)
+#define SPEED_144_CLKDIV_1  (6)
+#define SPEED_144_CLKPHASE_DEG_1  (122) // 125 not possible
+#define SPEED_108_CLKDIV_0  (8)
+#define SPEED_108_CLKDIV_1  (8)
+#define SPEED_108_CLKPHASE_DEG_1  (268) // 270 not possible
+
 /* Firmware Definitions */
 #define FIXED_PLL_FREQUENCY     (20000000)  // 20MHz
 #define INT_SYSTEM_C0_FREQUENCY (144000000) // 144 MHz

slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c

@@ -457,7 +457,7 @@ void setupDetector() {
         return;
     }
 
-    setClockDivider(RUN_CLK, HALF_SPEED);
+    setReadoutSpeed(HALF_SPEED);
     cleanFifos();
     resetCore();
 
@@ -487,8 +487,6 @@ void setupDetector() {
         // not applicable for chipv1.1
         setStorageCellDelay(DEFAULT_STRG_CLL_DLY);
     }
-    /*setClockDivider(RUN_CLK, HALF_SPEED); depends if all the previous stuff
-     * works*/
     setTiming(DEFAULT_TIMING_MODE);
     setNextFrameNumber(DEFAULT_STARTING_FRAME_NUMBER);
 
@@ -1823,11 +1821,7 @@ void configureASICTimer() {
                              ASIC_CTRL_DS_TMR_VAL);
 }
 
-int setClockDivider(enum CLKINDEX ind, int val) {
+int setReadoutSpeed(int val) {
-    if (ind != RUN_CLK) {
-        LOG(logERROR, ("Unknown clock index %d to set speed\n", ind));
-        return FAIL;
-    }
     // stop state machine if running
     if (runBusy()) {
         stopStateMachine();
@@ -1923,23 +1917,24 @@ int setClockDivider(enum CLKINDEX ind, int val) {
     return OK;
 }
 
-int getClockDivider(enum CLKINDEX ind) {
+int getReadoutSpeed(int* retval) {
-    if (ind != RUN_CLK) {
-        LOG(logERROR, ("Unknown clock index %d to get speed\n", ind));
-        return -1;
-    }
     u_int32_t speed = bus_r(CONFIG_REG) & CONFIG_READOUT_SPEED_MSK;
     switch (speed) {
     case CONFIG_FULL_SPEED_40MHZ_VAL:
-        return FULL_SPEED;
+        *retval = FULL_SPEED;
+        break;
     case CONFIG_HALF_SPEED_20MHZ_VAL:
-        return HALF_SPEED;
+        *retval = HALF_SPEED;
+        break;
     case CONFIG_QUARTER_SPEED_10MHZ_VAL:
-        return QUARTER_SPEED;
+        *retval = QUARTER_SPEED;
+        break;
     default:
         LOG(logERROR, ("Unknown speed val: %d\n", speed));
-        return -1;
+        *retval = -1;
+        return FAIL;
     }
+    return OK;
 }
 
 int setPhase(enum CLKINDEX ind, int val, int degrees) {

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -470,8 +470,8 @@ int autoCompDisable(int on);
 int setComparatorDisableTime(int64_t val);
 int64_t getComparatorDisableTime();
 void configureASICTimer();
-int setClockDivider(enum CLKINDEX ind, int val);
+int setReadoutSpeed(int val);
-int getClockDivider(enum CLKINDEX ind);
+int getReadoutSpeed(int* retval);
 int setPhase(enum CLKINDEX ind, int val, int degrees);
 int getPhase(enum CLKINDEX ind, int degrees);
 int getMaxPhase(enum CLKINDEX ind);
@@ -495,8 +495,8 @@ uint64_t getSelectCurrentSource();
 
 // eiger specific - iodelay, pulse, rate, temp, activate, delay nw parameter
 #elif EIGERD
-int setClockDivider(enum CLKINDEX ind, int val);
+int setReadoutSpeed(int val);
-int getClockDivider(enum CLKINDEX ind);
+int getReadoutSpeed(int* retval);
 int setIODelay(int val);
 int setCounterBit(int val);
 int pulsePixel(int n, int x, int y);
@@ -548,6 +548,8 @@ int validatePhaseinDegrees(enum CLKINDEX ind, int val, int retval);
 // void       	setFrequency(enum CLKINDEX ind, int val);
 int getFrequency(enum CLKINDEX ind);
 int getVCOFrequency(enum CLKINDEX ind);
+int setReadoutSpeed(int val);
+int getReadoutSpeed(int* retval);
 int getMaxClockDivider();
 int setClockDivider(enum CLKINDEX ind, int val);
 int getClockDivider(enum CLKINDEX ind);

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -273,3 +273,5 @@ int get_num_dest_list(int);
 int clear_all_udp_dst(int);
 int get_udp_first_dest(int);
 int set_udp_first_dest(int);
+int get_readout_speed(int);
+int set_readout_speed(int);

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -410,7 +410,8 @@ void function_table() {
     flist[F_CLEAR_ALL_UDP_DEST] = &clear_all_udp_dst;
     flist[F_GET_UDP_FIRST_DEST] = &get_udp_first_dest;
     flist[F_SET_UDP_FIRST_DEST] = &set_udp_first_dest;
-
+    flist[F_GET_READOUT_SPEED] = &get_readout_speed;
+    flist[F_SET_READOUT_SPEED] = &set_readout_speed;
     // check
     if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
         LOG(logERROR, ("The last detector function enum has reached its "
@@ -6010,45 +6011,21 @@ int set_clock_divider(int file_des) {
         return printSocketReadError();
     LOG(logDEBUG1, ("Setting clock (%d) divider: %u\n", args[0], args[1]));
 
-#if !defined(EIGERD) && !defined(JUNGFRAUD) && !defined(GOTTHARD2D) &&         \
+#if !defined(GOTTHARD2D) && !defined(MYTHEN3D)
-    !defined(MYTHEN3D)
     functionNotImplemented();
 #else
     // only set
     if (Server_VerifyLock() == OK) {
-        int ind = args[0];
+
-        int val = args[1];
+        if (args[0] >= NUM_CLOCKS) {
-        enum CLKINDEX c = 0;
+            modeNotImplemented("clock index (divider set)", args[0]);
-        switch (ind) {
-            // specific clock index
-#if defined(EIGERD) || defined(JUNGFRAUD)
-        case RUN_CLOCK:
-            c = RUN_CLK;
-            break;
-#endif
-        default:
-            // any clock index
-#if defined(GOTTHARD2D) || defined(MYTHEN3D)
-            if (ind < NUM_CLOCKS) {
-                c = (enum CLKINDEX)ind;
-                break;
-            }
-#endif
-            modeNotImplemented("clock index (divider set)", ind);
-            break;
         } 
 
+        enum CLKINDEX c = 0;
+        int val = args[1];
+        if (ret == OK) {
+            c = (enum CLKINDEX)args[0];
             // validate val range
-        if (ret != FAIL) {
-#ifdef JUNGFRAUD
-            if (val == (int)FULL_SPEED && isHardwareVersion2()) {
-                ret = FAIL;
-                strcpy(mess,
-                       "Full speed not implemented for this board version.\n");
-                LOG(logERROR, (mess));
-            } else
-#endif
-#if defined(GOTTHARD2D) || defined(MYTHEN3D)
             if (val < 2 || val > getMaxClockDivider()) {
                 char *clock_names[] = {CLK_NAMES};
                 ret = FAIL;
@@ -6058,24 +6035,12 @@ int set_clock_divider(int file_des) {
                         clock_names[c], (int)c, val, getMaxClockDivider());
                 LOG(logERROR, (mess));
             }
-#else
-            if (val < (int)FULL_SPEED || val > (int)QUARTER_SPEED) {
-                ret = FAIL;
-                sprintf(mess,
-                        "Cannot set speed to %d. Value should be in range "
-                        "[%d-%d]\n",
-                        val, (int)FULL_SPEED, (int)QUARTER_SPEED);
-                LOG(logERROR, (mess));
-            }
-#endif
         }
 
         if (ret != FAIL) {
-            char modeName[50] = "speed";
+            char modeName[50];
-#if defined(GOTTHARD2D) || defined(MYTHEN3D)
             char *clock_names[] = {CLK_NAMES};
             sprintf(modeName, "%s clock (%d) divider", clock_names[c], (int)c);
-#endif
             if (getClockDivider(c) == val) {
                 LOG(logINFO, ("Same %s: %d\n", modeName, val));
             } else {
@@ -6105,29 +6070,15 @@ int get_clock_divider(int file_des) {
         return printSocketReadError();
     LOG(logDEBUG1, ("Getting clock (%d) divider\n", arg));
 
-#if !defined(EIGERD) && !defined(JUNGFRAUD) && !defined(GOTTHARD2D) &&         \
+#if !defined(GOTTHARD2D) && !defined(MYTHEN3D)
-    !defined(MYTHEN3D)
     functionNotImplemented();
 #else
     // get only
-    enum CLKINDEX c = 0;
+        if (arg >= NUM_CLOCKS) {
-    switch (arg) {
+            modeNotImplemented("clock index (divider set)", arg);
-#if defined(EIGERD) || defined(JUNGFRAUD)
-    case RUN_CLOCK:
-        c = RUN_CLK;
-        break;
-#endif
-    default:
-#if defined(GOTTHARD2D) || defined(MYTHEN3D)
-        if (arg < NUM_CLOCKS) {
-            c = (enum CLKINDEX)arg;
-            break;
-        }
-#endif
-        modeNotImplemented("clock index (divider get)", arg);
-        break;
         } 
     if (ret == OK) {
+        enum CLKINDEX c = (enum CLKINDEX)arg;    
         retval = getClockDivider(c);
         char *clock_names[] = {CLK_NAMES};
         LOG(logDEBUG1, ("retval %s clock (%d) divider: %d\n", clock_names[c],
@@ -9288,3 +9239,84 @@ int set_udp_first_dest(int file_des) {
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);
 }
+
+
+int get_readout_speed(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+    LOG(logDEBUG1, ("Getting readout speed\n"));
+
+#if !defined(JUNGFRAUD) && !defined(EIGER) && !defined(GOTTHARD2D)
+    functionNotImplemented();
+#else
+    // get only
+    ret = getReadoutSpeed(&retval);
+    LOG(logDEBUG1, ("retval readout speed: %d\n", retval));
+    if (ret == FAIL) {
+        strcpy(mess, "Could not get readout speed\n");
+        LOG(logERROR, (mess));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_readout_speed(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = -1;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logDEBUG1, ("Setting readout speed : %u\n", arg));
+
+#if !defined(JUNGFRAUD) && !defined(EIGER) && !defined(GOTTHARD2D)
+    functionNotImplemented();
+#else
+    // only set
+    if (Server_VerifyLock() == OK) {
+#ifdef JUNGFRAUD
+        if (arg == (int)FULL_SPEED && isHardwareVersion2()) {
+            ret = FAIL;
+            strcpy(mess,
+                    "Full speed not implemented for this board version (v1.0).\n");
+            LOG(logERROR, (mess));
+        } 
+#endif   
+        if (ret == OK) {
+            switch (arg) {
+#if defined(EIGERD) || defined(JUNGFRAUD)
+                case FULL_SPEED:
+                case HALF_SPEED:
+                case QUARTER_SPEED:
+#elif GOTTHARD2D
+                case G2_108MHZ:
+                case G2_144MHZ:
+#endif
+                    break;
+                default:
+                    modeNotImplemented("readout speed index", arg);
+                    break;
+            }
+            if (ret == OK) {
+                ret = setReadoutSpeed(arg);
+                if (ret == FAIL) {
+                    sprintf(mess, "Could not set readout speed to %d.\n", arg);
+                    LOG(logERROR, (mess));
+                } else {
+                    int retval = 0;
+                    ret = getReadoutSpeed(&retval);
+                    LOG(logDEBUG1, ("retval readout speed: %d\n", retval));
+                    if (ret == FAIL) {
+                        strcpy(mess, "Could not get readout speed\n");
+                        LOG(logERROR, (mess));
+                    }
+                    validate(&ret, mess, arg, retval, "set readout speed", DEC);
+                }
+            }
+        }
+
+    }
+#endif
+    return Server_SendResult(file_des, INT32, NULL, 0);
+}

slsDetectorSoftware/include/sls/Detector.h

@@ -300,16 +300,21 @@ class Detector {
     /** list of possible timing modes for this detector */
     std::vector<defs::timingMode> getTimingModeList() const;
 
-    /** [Eiger][Jungfrau] */
+    /** [Eiger][Jungfrau][Gotthard2] */
-    Result<defs::speedLevel> getSpeed(Positions pos = {}) const;
+    Result<defs::speedLevel> getReadoutSpeed(Positions pos = {}) const;
 
-    /** [Eiger][Jungfrau]
+    /** [Eiger][Jungfrau][Gotthard2]
-     * Options: FULL_SPEED, HALF_SPEED, QUARTER_SPEED \n
+     * [Jungfrau] Options: FULL_SPEED, HALF_SPEED (Default), QUARTER_SPEED \n
-     * [Jungfrau] FULL_SPEED option only available from v2.0 boards and with
+     * [Eiger] Options: FULL_SPEED (Default), HALF_SPEED, QUARTER_SPEED \n
-     * setting number of interfaces to 2.  \n Also overwrites adcphase to
+     * [Gotthard2] Options: G2_108MHZ (Default), G2_144MHZ \n
+     * [Jungfrau] FULL_SPEED option only available from v2.0 boards and is 
+     * recommended to set number of interfaces to 2. \n Also overwrites adcphase to
      * recommended default.
      */
-    void setSpeed(defs::speedLevel value, Positions pos = {});
+    void setReadoutSpeed(defs::speedLevel value, Positions pos = {});
+
+    /** list of possible readoutspeed modes for this detector */
+    std::vector<defs::speedLevel> getReadoutSpeedList() const;
 
     /** [Jungfrau][CTB][Moench] */
     Result<int> getADCPhase(Positions pos = {}) const;

slsDetectorSoftware/src/CmdProxy.cpp

@@ -605,57 +605,37 @@ std::string CmdProxy::Exptime(int action) {
     return os.str();
 }
 
-std::string CmdProxy::Speed(int action) {
+std::string CmdProxy::ReadoutSpeed(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "[0 or full_speed|1 or half_speed|2 or "
+        os << "\n\t[0 or full_speed|1 or half_speed|2 or "
-              "quarter_speed]\n\t[Eiger][Jungfrau] Readout speed of "
+        "quarter_speed]\n\t\t[Eiger][Jungfrau] Readout "
-              "chip.\n\t[Jungfrau] FULL_SPEED option only available from v2.0 "
+        "speed of chip.\n\t\t[Eiger] Default speed is full_speed."
-              "boards and with setting number of interfaces to 2. Also "
+        "\n\t\t[Jungfrau] Default speed is half_speed. full_speed "
-              "overwrites adcphase to recommended default. "
+        "option only available from v2.0 boards and is recommended to set "
+        "number of interfaces to 2. Also overwrites "
+        "adcphase to recommended default.\n\t [144|108]\n\t\t[Gotthard2] "
+        "Readout speed of chip in MHz. Default is 108."
            << '\n';
     } else {
         defs::detectorType type = det->getDetectorType().squash();
         if (type == defs::CHIPTESTBOARD || type == defs::MOENCH) {
             throw sls::RuntimeError(
-                "Speed not implemented. Did you mean runclk?");
+                "ReadoutSpeed not implemented. Did you mean runclk?");
-        }
-        if (type != defs::EIGER && type != defs::JUNGFRAU) {
-            throw sls::RuntimeError(
-                "Speed not implemented."); // setspped one function problem. tbr
-                                           // after change
         }
         if (action == defs::GET_ACTION) {
             if (!args.empty()) {
                 WrongNumberOfParameters(0);
             }
-            auto t = det->getSpeed(std::vector<int>{det_id});
+            auto t = det->getReadoutSpeed(std::vector<int>{det_id});
             os << OutString(t) << '\n';
         } else if (action == defs::PUT_ACTION) {
             if (args.size() != 1) {
                 WrongNumberOfParameters(1);
             }
-            defs::speedLevel t;
+            defs::speedLevel t = sls::StringTo<defs::speedLevel>(args[0]);
-            try {
+            det->setReadoutSpeed(t, std::vector<int>{det_id});
-                int ival = StringTo<int>(args[0]);
-                switch (ival) {
-                case 0:
-                    t = defs::FULL_SPEED;
-                    break;
-                case 1:
-                    t = defs::HALF_SPEED;
-                    break;
-                case 2:
-                    t = defs::QUARTER_SPEED;
-                    break;
-                default:
-                    throw sls::RuntimeError("Unknown speed " + args[0]);
-                }
-            } catch (...) {
-                t = sls::StringTo<defs::speedLevel>(args[0]);
-            }
-            det->setSpeed(t, std::vector<int>{det_id});
             os << sls::ToString(t) << '\n'; // no args to convert 0,1,2 as well
         } else {
             throw sls::RuntimeError("Unknown action");

slsDetectorSoftware/src/CmdProxy.h

@@ -591,7 +591,8 @@ class CmdProxy {
         /* acquisition parameters */
         {"cycles", "triggers"},
         {"cyclesl", "triggersl"},
-        {"clkdivider", "speed"},
+        {"clkdivider", "readoutspeed"},
+        {"speed", "readoutspeed"},
         {"vhighvoltage", "highvoltage"},
         {"digitest", "imagetest"},
         {"filter", "filterresistor"},
@@ -792,7 +793,8 @@ class CmdProxy {
         {"drlist", &CmdProxy::drlist},
         {"timing", &CmdProxy::timing},
         {"timinglist", &CmdProxy::timinglist},
-        {"speed", &CmdProxy::Speed},
+        {"readoutspeed", &CmdProxy::ReadoutSpeed},
+        {"readoutspeedlist", &CmdProxy::readoutspeedlist},
         {"adcphase", &CmdProxy::Adcphase},
         {"maxadcphaseshift", &CmdProxy::maxadcphaseshift},
         {"dbitphase", &CmdProxy::Dbitphase},
@@ -1097,7 +1099,7 @@ class CmdProxy {
     std::string Acquire(int action);
     std::string Exptime(int action);
     std::string DynamicRange(int action);
-    std::string Speed(int action);
+    std::string ReadoutSpeed(int action);
     std::string Adcphase(int action);
     std::string Dbitphase(int action);
     std::string ClockFrequency(int action);
@@ -1328,6 +1330,10 @@ class CmdProxy {
     GET_COMMAND_NOID(timinglist, getTimingModeList,
                      "\n\tGets the list of timing modes for this detector.");
 
+    GET_COMMAND_NOID(readoutspeedlist, getReadoutSpeedList,
+                     "\n\tList of readout speed levels implemented for this detector.");
+
+
     GET_COMMAND(maxadcphaseshift, getMaxADCPhaseShift,
                 "\n\t[Jungfrau][CTB][Moench] Absolute maximum Phase shift of "
                 "ADC clock.");

slsDetectorSoftware/src/Detector.cpp

@@ -412,20 +412,31 @@ std::vector<defs::timingMode> Detector::getTimingModeList() const {
     }
 }
 
-Result<defs::speedLevel> Detector::getSpeed(Positions pos) const {
+Result<defs::speedLevel> Detector::getReadoutSpeed(Positions pos) const {
-    auto res = pimpl->Parallel(&Module::getClockDivider, pos, defs::RUN_CLOCK);
+    return pimpl->Parallel(&Module::getReadoutSpeed, pos);
-    Result<defs::speedLevel> speedResult(res.size());
-    for (unsigned int i = 0; i < res.size(); ++i) {
-        speedResult[i] = static_cast<defs::speedLevel>(res[i]);
-    }
-    return speedResult;
 }
 
-void Detector::setSpeed(defs::speedLevel value, Positions pos) {
+void Detector::setReadoutSpeed(defs::speedLevel value, Positions pos) {
-    pimpl->Parallel(&Module::setClockDivider, pos, defs::RUN_CLOCK,
+    pimpl->Parallel(&Module::setReadoutSpeed, pos, value);
-                    static_cast<int>(value));
 }
 
+
+std::vector<defs::speedLevel> Detector::getReadoutSpeedList() const {
+    switch (getDetectorType().squash()) {
+    case defs::EIGER:
+    case defs::JUNGFRAU:
+        return std::vector<defs::speedLevel>{defs::FULL_SPEED,
+                                             defs::HALF_SPEED,
+                                             defs::QUARTER_SPEED};
+    case defs::GOTTHARD2:
+        return std::vector<defs::speedLevel>{defs::G2_108MHZ,
+                                             defs::G2_144MHZ};
+    default:
+        throw RuntimeError("Readout speed not implemented for this detector");
+    }
+}
+
+
 Result<int> Detector::getADCPhase(Positions pos) const {
     return pimpl->Parallel(&Module::getClockPhase, pos, defs::ADC_CLOCK, false);
 }

slsDetectorSoftware/src/Module.cpp

@@ -600,6 +600,14 @@ void Module::setTimingMode(timingMode value) {
     }
 }
 
+slsDetectorDefs::speedLevel Module::getReadoutSpeed() const {
+    return sendToDetector<speedLevel>(F_GET_READOUT_SPEED);
+}
+
+void Module::setReadoutSpeed(speedLevel value) {
+    sendToDetector(F_SET_READOUT_SPEED, value, nullptr);
+}
+
 int Module::getClockDivider(int clkIndex) const {
     return sendToDetector<int>(F_GET_CLOCK_DIVIDER, clkIndex);
 }

slsDetectorSoftware/src/Module.h

@@ -144,6 +144,8 @@ class Module : public virtual slsDetectorDefs {
     void setDynamicRange(int dr);
     timingMode getTimingMode() const;
     void setTimingMode(timingMode value);
+    speedLevel getReadoutSpeed() const;
+    void setReadoutSpeed(speedLevel value);
     int getClockDivider(int clkIndex) const;
     void setClockDivider(int clkIndex, int value);
     int getClockPhase(int clkIndex, bool inDegrees) const;

slsDetectorSoftware/tests/test-CmdProxy.cpp

@@ -889,57 +889,94 @@ TEST_CASE("timinglist", "[.cmd]") {
     REQUIRE_THROWS(proxy.Call("timinglist", {}, -1, PUT));
 }
 
-TEST_CASE("speed", "[.cmd]") {
+TEST_CASE("readoutspeed", "[.cmd]") {
     Detector det;
     CmdProxy proxy(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type == defs::EIGER || det_type == defs::JUNGFRAU || det_type == defs::GOTTHARD2) {
+        auto prev_val = det.getReadoutSpeed();
+
+        // full speed for jungfrau only works for new boards (chipv1.1 is with new board [hw1.0 and chipv1.0 not tested here])
+        if ((det_type == defs::JUNGFRAU && det.getChipVersion().squash() * 10 == 11) || (det_type == defs::EIGER))
+        {
+            std::ostringstream oss1, oss2, oss3, oss4;
+            proxy.Call("readoutspeed", {"0"}, -1, PUT, oss1);
+            REQUIRE(oss1.str() == "readoutspeed full_speed\n");
+            proxy.Call("readoutspeed", {}, -1, GET, oss2);
+            REQUIRE(oss2.str() == "readoutspeed full_speed\n");
+            proxy.Call("readoutspeed", {"full_speed"}, -1, PUT, oss3);
+            REQUIRE(oss3.str() == "readoutspeed full_speed\n");
+            proxy.Call("readoutspeed", {}, -1, GET, oss4);
+            REQUIRE(oss4.str() == "readoutspeed full_speed\n");
+        }
+        
         if (det_type == defs::EIGER || det_type == defs::JUNGFRAU) {
-        auto prev_val = det.getSpeed();
-        // full speed for jungfrau only works for new boards
-        /*
             {
                 std::ostringstream oss1, oss2, oss3, oss4;
-            proxy.Call("speed", {"0"}, -1, PUT, oss1);
+                proxy.Call("readoutspeed", {"1"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "speed full_speed\n");
+                REQUIRE(oss1.str() == "readoutspeed half_speed\n");
-            proxy.Call("speed", {}, -1, GET, oss2);
+                proxy.Call("readoutspeed", {}, -1, GET, oss2);
-            REQUIRE(oss2.str() == "speed full_speed\n");
+                REQUIRE(oss2.str() == "readoutspeed half_speed\n");
-            proxy.Call("speed", {"full_speed"}, -1, PUT, oss3);
+                proxy.Call("readoutspeed", {"half_speed"}, -1, PUT, oss3);
-            REQUIRE(oss3.str() == "speed full_speed\n");
+                REQUIRE(oss3.str() == "readoutspeed half_speed\n");
-            proxy.Call("speed", {}, -1, GET, oss4);
+                proxy.Call("readoutspeed", {}, -1, GET, oss4);
-            REQUIRE(oss4.str() == "speed full_speed\n");
+                REQUIRE(oss4.str() == "readoutspeed half_speed\n");
-        }
-        */
-        {
-            std::ostringstream oss1, oss2, oss3, oss4;
-            proxy.Call("speed", {"1"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "speed half_speed\n");
-            proxy.Call("speed", {}, -1, GET, oss2);
-            REQUIRE(oss2.str() == "speed half_speed\n");
-            proxy.Call("speed", {"half_speed"}, -1, PUT, oss3);
-            REQUIRE(oss3.str() == "speed half_speed\n");
-            proxy.Call("speed", {}, -1, GET, oss4);
-            REQUIRE(oss4.str() == "speed half_speed\n");
             }
             {
                 std::ostringstream oss1, oss2, oss3, oss4;
-            proxy.Call("speed", {"2"}, -1, PUT, oss1);
+                proxy.Call("readoutspeed", {"2"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "speed quarter_speed\n");
+                REQUIRE(oss1.str() == "readoutspeed quarter_speed\n");
-            proxy.Call("speed", {}, -1, GET, oss2);
+                proxy.Call("readoutspeed", {}, -1, GET, oss2);
-            REQUIRE(oss2.str() == "speed quarter_speed\n");
+                REQUIRE(oss2.str() == "readoutspeed quarter_speed\n");
-            proxy.Call("speed", {"quarter_speed"}, -1, PUT, oss3);
+                proxy.Call("readoutspeed", {"quarter_speed"}, -1, PUT, oss3);
-            REQUIRE(oss3.str() == "speed quarter_speed\n");
+                REQUIRE(oss3.str() == "readoutspeed quarter_speed\n");
-            proxy.Call("speed", {}, -1, GET, oss4);
+                proxy.Call("readoutspeed", {}, -1, GET, oss4);
-            REQUIRE(oss4.str() == "speed quarter_speed\n");
+                REQUIRE(oss4.str() == "readoutspeed quarter_speed\n");
             }
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"108"}, -1, PUT));
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"144"}, -1, PUT));
+        }
+
+        if (det_type == defs::GOTTHARD2) {
+            {
+                std::ostringstream oss1, oss2, oss3, oss4;
+                proxy.Call("readoutspeed", {"108"}, -1, PUT, oss1);
+                REQUIRE(oss1.str() == "readoutspeed 108\n");
+                proxy.Call("readoutspeed", {}, -1, GET, oss2);
+                REQUIRE(oss2.str() == "readoutspeed 108\n");
+            }
+
+            {
+                std::ostringstream oss1, oss2, oss3, oss4;
+                proxy.Call("readoutspeed", {"144"}, -1, PUT, oss1);
+                REQUIRE(oss1.str() == "readoutspeed 144\n");
+                proxy.Call("readoutspeed", {}, -1, GET, oss2);
+                REQUIRE(oss2.str() == "readoutspeed 144\n");
+            } 
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"full_speed"}, -1, PUT));
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"half_speed"}, -1, PUT));
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"quarter_speed"}, -1, PUT));
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"0"}, -1, PUT));
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"1"}, -1, PUT));
+            REQUIRE_THROWS(proxy.Call("readoutspeed", {"2"}, -1, PUT));
+        }
+
         for (int i = 0; i != det.size(); ++i) {
-            det.setSpeed(prev_val[i], {i});
+            det.setReadoutSpeed(prev_val[i], {i});
         }
     } else {
-        REQUIRE_THROWS(proxy.Call("speed", {"0"}, -1, PUT));
+        REQUIRE_THROWS(proxy.Call("readoutspeed", {"0"}, -1, PUT));
-        REQUIRE_THROWS(proxy.Call("speed", {}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("readoutspeed", {}, -1, GET));
     }
 }
 
+TEST_CASE("readoutspeedlist", "[.cmd]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    REQUIRE_NOTHROW(proxy.Call("readoutspeedlist", {}, -1, GET));
+    REQUIRE_THROWS(proxy.Call("readoutspeedlist", {}, -1, PUT));
+}
+
 TEST_CASE("adcphase", "[.cmd]") {
     Detector det;
     CmdProxy proxy(&det);

slsSupportLib/include/sls/sls_detector_defs.h

@@ -377,7 +377,7 @@ typedef struct {
     enum readoutMode { ANALOG_ONLY, DIGITAL_ONLY, ANALOG_AND_DIGITAL };
 
     /** chip speed */
-    enum speedLevel { FULL_SPEED, HALF_SPEED, QUARTER_SPEED };
+    enum speedLevel { FULL_SPEED, HALF_SPEED, QUARTER_SPEED, G2_108MHZ, G2_144MHZ };
 
     /**
      * burst mode for gotthard2

slsSupportLib/include/sls/sls_detector_funcs.h

@@ -249,6 +249,8 @@ enum detFuncs {
     F_CLEAR_ALL_UDP_DEST,
     F_GET_UDP_FIRST_DEST,
     F_SET_UDP_FIRST_DEST,
+    F_GET_READOUT_SPEED,
+    F_SET_READOUT_SPEED,
 
     NUM_DET_FUNCTIONS,
     RECEIVER_ENUM_START = 256, /**< detector function should not exceed this
@@ -602,7 +604,8 @@ const char* getFunctionNameFromEnum(enum detFuncs func) {
     case F_CLEAR_ALL_UDP_DEST:              return "F_CLEAR_ALL_UDP_DEST";
     case F_GET_UDP_FIRST_DEST:              return "F_GET_UDP_FIRST_DEST";
     case F_SET_UDP_FIRST_DEST:              return "F_SET_UDP_FIRST_DEST";
-
+    case F_GET_READOUT_SPEED:               return "F_GET_READOUT_SPEED";
+    case F_SET_READOUT_SPEED:               return "F_SET_READOUT_SPEED";
     case NUM_DET_FUNCTIONS:              	return "NUM_DET_FUNCTIONS";
     case RECEIVER_ENUM_START:				return "RECEIVER_ENUM_START";
 

slsSupportLib/include/sls/versionAPI.h

@@ -1,13 +1,13 @@
 /** API versions */
-#define GITBRANCH    "udp_numdst"
+#define GITBRANCH    "g2speed"
 
-#define APILIB 0x210917
+#define APICTB 0x211007
-#define APIRECEIVER 0x210917
+#define APIGOTTHARD 0x211007
+#define APIMYTHEN3 0x211007
+#define APIMOENCH 0x211005
+#define APIEIGER 0x211007
+#define APILIB 0x211007
+#define APIRECEIVER 0x211007
 #define APIGUI 0x210819
-#define APICTB 0x211005
+#define APIJUNGFRAU 0x211008
-#define APIGOTTHARD 0x211005
+#define APIGOTTHARD2 0x211008
-#define APIGOTTHARD2 0x211005
-#define APIMYTHEN3 0x211005
-#define APIMOENCH 0x210927
-#define APIEIGER 0x211005
-#define APIJUNGFRAU 0x211007

slsSupportLib/src/ToString.cpp

@@ -247,6 +247,10 @@ std::string ToString(const defs::speedLevel s) {
         return std::string("half_speed");
     case defs::QUARTER_SPEED:
         return std::string("quarter_speed");
+    case defs::G2_108MHZ:
+        return std::string("108");
+    case defs::G2_144MHZ:
+        return std::string("144");        
     default:
         return std::string("Unknown");
     }
@@ -703,10 +707,20 @@ template <> defs::detectorSettings StringTo(const std::string &s) {
 template <> defs::speedLevel StringTo(const std::string &s) {
     if (s == "full_speed")
         return defs::FULL_SPEED;
+    if (s == "0")
+        return defs::FULL_SPEED;
     if (s == "half_speed")
         return defs::HALF_SPEED;
+    if (s == "1")
+        return defs::HALF_SPEED;
     if (s == "quarter_speed")
         return defs::QUARTER_SPEED;
+    if (s == "2")
+        return defs::QUARTER_SPEED;
+    if (s == "108")
+        return defs::G2_108MHZ;
+    if (s == "144")
+        return defs::G2_144MHZ;
     throw sls::RuntimeError("Unknown speed " + s);
 }
 

slsSupportLib/tests/test-ToString.cpp

@@ -331,3 +331,21 @@ TEST_CASE("streamingInterface") {
     REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK |
                      sls::defs::streamingInterface::ETHERNET_10GB) == "lll, 10gbe");
 }
+
+
+//Speed level 
+TEST_CASE("speedLevel to string"){
+    REQUIRE(ToString(sls::defs::speedLevel::FULL_SPEED) == "full_speed");
+    REQUIRE(ToString(sls::defs::speedLevel::HALF_SPEED) == "half_speed");
+    REQUIRE(ToString(sls::defs::speedLevel::QUARTER_SPEED) == "quarter_speed");
+    REQUIRE(ToString(sls::defs::speedLevel::G_108MHZ) == "108");
+    REQUIRE(ToString(sls::defs::speedLevel::G_144MHZ) == "144");
+}
+
+TEST_CASE("string to speedLevel"){
+    REQUIRE(StringTo<sls::defs::speedLevel>("full_speed") == sls::defs::speedLevel::FULL_SPEED);
+    REQUIRE(StringTo<sls::defs::speedLevel>("half_speed") == sls::defs::speedLevel::HALF_SPEED);
+    REQUIRE(StringTo<sls::defs::speedLevel>("quarter_speed") == sls::defs::speedLevel::QUARTER_SPEED);
+    REQUIRE(StringTo<sls::defs::speedLevel>("108") == sls::defs::speedLevel::G_108MHZ);
+    REQUIRE(StringTo<sls::defs::speedLevel>("144") == sls::defs::speedLevel::G_144MHZ);
+}