binaries in and updated api versioning

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() {
@@ -2084,7 +2085,36 @@ int getVCOFrequency(enum CLKINDEX ind) {
 }
 
 int setReadoutSpeed(int val) {
-    switch (val)
+    switch (val) {
+        case G_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 G_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) {
@@ -2092,13 +2122,13 @@ int getReadoutSpeed(int* retval) {
 // clkdiv 2, 3, 4, 5?
     if (clkDivider[READOUT_C0] == SPEED_108_CLKDIV_0 &&
      clkDivider[READOUT_C1] == SPEED_108_CLKDIV_1 && 
-     getPhase(READOUT_C0, 1) == SPEED_108_CLKPHASE_DEG_1) {
+     getPhase(READOUT_C1, 1) == SPEED_108_CLKPHASE_DEG_1) {
         *retval = G_108MHZ;
     }
 
     else if (clkDivider[READOUT_C0] == SPEED_144_CLKDIV_0 &&
      clkDivider[READOUT_C1] == SPEED_144_CLKDIV_1 && 
-     getPhase(READOUT_C0, 1) == SPEED_144_CLKPHASE_DEG_1) {
+     getPhase(READOUT_C1, 1) == SPEED_144_CLKPHASE_DEG_1) {
         *retval = G_144MHZ;
     }
     
@@ -2121,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,13 +59,13 @@
 #define DEFAULT_SYSTEM_C2  (5)  //(144444448) // sync_clk, 144 MHz
 #define DEFAULT_SYSTEM_C3  (5)  //(144444448) // str_clk, 144 MHz
 
-#define DEFAULT_READOUT_SPEED   (G_108MHz)
+#define DEFAULT_READOUT_SPEED   (G_108MHZ)
 #define SPEED_144_CLKDIV_0  (6)
 #define SPEED_144_CLKDIV_1  (6)
-#define SPEED_144_CLKPHASE_DEG_1  (125)
+#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  (270)
+#define SPEED_108_CLKPHASE_DEG_1  (268) // 270 not possible
 
 /* Firmware Definitions */
 #define FIXED_PLL_FREQUENCY     (20000000)  // 20MHz

slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c

@@ -1925,10 +1925,10 @@ int getReadoutSpeed(int* retval) {
     case CONFIG_HALF_SPEED_20MHZ_VAL:
         *retval = HALF_SPEED;
     case CONFIG_QUARTER_SPEED_10MHZ_VAL:
-        retval = QUARTER_SPEED;
+        *retval = QUARTER_SPEED;
     default:
         LOG(logERROR, ("Unknown speed val: %d\n", speed));
-        *retval == -1;
+        *retval = -1;
         return FAIL;
     }
     return OK;

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -6021,9 +6021,10 @@ int set_clock_divider(int file_des) {
             modeNotImplemented("clock index (divider set)", args[0]);
         } 
 
+        enum CLKINDEX c = 0;
+        int val = args[1];
         if (ret == OK) {
-            enum CLKINDEX c = (enum CLKINDEX)args[0];
+            c = (enum CLKINDEX)args[0];
-            int val = args[1];
             // validate val range
             if (val < 2 || val > getMaxClockDivider()) {
                 char *clock_names[] = {CLK_NAMES};
@@ -9284,7 +9285,7 @@ int set_readout_speed(int file_des) {
 #endif   
         if (ret == OK) {
             switch (arg) {
-#if defined(EIGERD) || !defined(JUNGFRAUD)
+#if defined(EIGERD) || defined(JUNGFRAUD)
                 case FULL_SPEED:
                 case HALF_SPEED:
                 case QUARTER_SPEED:
@@ -9297,18 +9298,21 @@ int set_readout_speed(int file_des) {
                     modeNotImplemented("readout speed index", arg);
                     break;
             }
-            ret = setReadoutSpeed(arg);
+            if (ret == OK) {
-            if (ret == FAIL) {
+                ret = setReadoutSpeed(arg);
-                sprintf(mess, "Could not set readout speed to %d.\n", arg);
-                LOG(logERROR, (mess));
-            } else {
-                ret = getReadoutSpeed(&retval);
-                LOG(logDEBUG1, ("retval readout speed: %d\n", retval));
                 if (ret == FAIL) {
-                    strcpy(mess, "Could not get readout speed\n");
+                    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);
                 }
-                validate(&ret, mess, arg, retval, "set readout speed", DEC);
             }
         }
 

slsDetectorSoftware/src/CmdProxy.cpp

@@ -637,25 +637,7 @@ std::string CmdProxy::ReadoutSpeed(int action) {
             if (args.size() != 1) {
                 WrongNumberOfParameters(1);
             }
-            defs::speedLevel t;
+            defs::speedLevel t = sls::StringTo<defs::speedLevel>(args[0]);
-            try {
-                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->setReadoutSpeed(t, std::vector<int>{det_id});
             os << sls::ToString(t) << '\n'; // no args to convert 0,1,2 as well
         } else {

slsDetectorSoftware/src/CmdProxy.h

@@ -793,7 +793,7 @@ class CmdProxy {
         {"drlist", &CmdProxy::drlist},
         {"timing", &CmdProxy::timing},
         {"timinglist", &CmdProxy::timinglist},
-        {"speed", &CmdProxy::ReadoutSpeed},
+        {"readoutspeed", &CmdProxy::ReadoutSpeed},
         {"adcphase", &CmdProxy::Adcphase},
         {"maxadcphaseshift", &CmdProxy::maxadcphaseshift},
         {"dbitphase", &CmdProxy::Dbitphase},

slsDetectorSoftware/src/Detector.cpp

@@ -417,7 +417,7 @@ Result<defs::speedLevel> Detector::getReadoutSpeed(Positions pos) const {
 }
 
 void Detector::setReadoutSpeed(defs::speedLevel value, Positions pos) {
-    pimpl->Parallel(&Module::getReadoutSpeed, pos, value);
+    pimpl->Parallel(&Module::setReadoutSpeed, pos, value);
 }
 
 

slsDetectorSoftware/src/Module.cpp

@@ -605,7 +605,7 @@ slsDetectorDefs::speedLevel Module::getReadoutSpeed() const {
 }
 
 void Module::setReadoutSpeed(speedLevel value) {
-    sendToDetector<int>(F_SET_READOUT_SPEED, value);
+    sendToDetector(F_SET_READOUT_SPEED, value, nullptr);
 }
 
 int Module::getClockDivider(int clkIndex) const {

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 APIGUI 0x210819
+#define APIGOTTHARD2 0x211007
-#define APICTB 0x211005
-#define APIGOTTHARD 0x211005
-#define APIGOTTHARD2 0x211005
-#define APIMYTHEN3 0x211005
-#define APIMOENCH 0x210927
-#define APIEIGER 0x211005
 #define APIJUNGFRAU 0x211007
+#define APIMYTHEN3 0x211007
+#define APIMOENCH 0x211005
+#define APIEIGER 0x211007
+#define APILIB 0x211007
+#define APIRECEIVER 0x211007
+#define APIGUI 0x210819

slsSupportLib/src/ToString.cpp

@@ -707,10 +707,16 @@ 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::G_108MHZ;
     if (s == "144")