Dev/xilinx set dac rewrite (#1389)

* wip

* wip

* wip. xilinx left

* wip. xilinx

* wip

* wip. compiles

* fixed eiger test

* more fixes

* fixed virtual m3

* fix typos and bugs

* setting power to 0

* set power fixed

* updated server binaries

* minor

* refactoring

* get vchip refactoring

* eiger: unnecessary check for setsettings undefined

* retval pointer for printout

* eiger.wip, mV in boolean

* wip. gotthard2 and m3

* wip. jungfrau

* moench.wip

* compiles.wip

* fix eiger

* m3 fix vthresh

* fix ctband xilinx

* default pwr index = pwr_io

* minor:fn name and highvoltage to local var

* refactor funcs

* minor

* minor

* check dac voltage only for normal dacs and not for power dacs as the dac voltage range is different for ctb and xilinx ctb, also throw for -1 in set for set_dac in client itself. in the server its not clear if its set or get with a -1

* minor

* updated versioning

* review changes: removing validateDACValue and other minor stuff

* binaries in

* wip

* refactored m3 vth

* minor review

* minor review

* m3 serverdac index fix

* minor

slsDetectorServers/ctbDetectorServer/RegisterDefs.h

@@ -438,6 +438,16 @@
 
 #define POWER_ENBL_VLTG_RGLTR_OFST  (16)
 #define POWER_ENBL_VLTG_RGLTR_MSK   (0x0000001F << POWER_ENBL_VLTG_RGLTR_OFST)
+#define POWER_ENBL_VIO_OFST         (16)
+#define POWER_ENBL_VIO_MSK          (0x00000001 << POWER_ENBL_VIO_OFST)
+#define POWER_ENBL_VA_OFST          (17)
+#define POWER_ENBL_VA_MSK           (0x00000001 << POWER_ENBL_VA_OFST)
+#define POWER_ENBL_VB_OFST          (18)
+#define POWER_ENBL_VB_MSK           (0x00000001 << POWER_ENBL_VB_OFST)
+#define POWER_ENBL_VC_OFST          (19)
+#define POWER_ENBL_VC_MSK           (0x00000001 << POWER_ENBL_VC_OFST)
+#define POWER_ENBL_VD_OFST          (20)
+#define POWER_ENBL_VD_MSK           (0x00000001 << POWER_ENBL_VD_OFST)
 #define POWER_HV_INTERNAL_SLCT_OFST (31)
 #define POWER_HV_INTERNAL_SLCT_MSK  (0x00000001 << POWER_HV_INTERNAL_SLCT_OFST)
 

slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c

@@ -568,7 +568,9 @@ void setupDetector() {
                        SPI_HV_SRL_DGTL_OTPT_MSK, SPI_HV_SRL_DGTL_OTPT_OFST,
                        HIGHVOLTAGE_MIN, HIGHVOLTAGE_MAX);
     MAX1932_Disable();
-    setHighVoltage(DEFAULT_HIGH_VOLTAGE);
+    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     // power off voltage regulators
     powerOff();
@@ -587,15 +589,28 @@ void setupDetector() {
                        DAC_MAX_MV); // has to be before setvchip
     LTC2620_Disable();
     LTC2620_Configure();
-    // switch off dacs (power regulators most likely only sets to minimum (if
-    // power enable on))
+
+    // dacs only
     LOG(logINFOBLUE, ("Powering down all dacs\n"));
-    for (int idac = 0; idac < NDAC; ++idac) {
-        setDAC(idac, LTC2620_GetPowerDownValue(),
-               0); // has to be before setvchip
+    for (int idac = 0; idac < NDAC_ONLY; ++idac) {
+        initError =
+            setDAC(idac, LTC2620_GetPowerDownValue(), false, initErrorMessage);
+        if (initError == FAIL)
+            return;
     }
 
     // power regulators
+    LOG(logINFOBLUE,
+        ("Setting power dacs to min dac value (power disabled)\n"));
+    for (int idac = NDAC_ONLY; idac < NDAC; ++idac) {
+        if (idac == D_PWR_CHIP)
+            continue;
+        int min = (idac == D_PWR_IO) ? VIO_MIN_MV : POWER_RGLTR_MIN;
+        initError = setDAC(idac, min, true, initErrorMessage);
+        if (initError == FAIL)
+            return;
+    }
+
     // I2C
     INA226_ConfigureI2CCore(I2C_SHUNT_RESISTER_OHMS, I2C_CONTROL_REG,
                             I2C_STATUS_REG, I2C_RX_DATA_FIFO_REG,
@@ -607,7 +622,9 @@ void setupDetector() {
     INA226_CalibrateCurrentRegister(I2C_POWER_VB_DEVICE_ID);
     INA226_CalibrateCurrentRegister(I2C_POWER_VC_DEVICE_ID);
     INA226_CalibrateCurrentRegister(I2C_POWER_VD_DEVICE_ID);
-    setVchip(VCHIP_MIN_MV);
+    initError = setVchip(VCHIP_MIN_MV, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     setADCInvertRegister(0); // depends on chip
 
@@ -1223,345 +1240,466 @@ int64_t getMeasurementTime() {
 enum detectorSettings getSettings() { return UNDEFINED; }
 
 /* parameters - dac, adc, hv */
-
-void setDAC(enum DACINDEX ind, int val, int mV) {
-    if (val < 0 && val != LTC2620_GetPowerDownValue())
-        return;
-
-    LOG(logDEBUG1, ("Setting dac[%d]: %d %s \n", (int)ind, val,
-                    (mV ? "mV" : "dac units")));
-    int dacval = val;
-#ifdef VIRTUAL
-    if (!mV) {
-        dacValues[ind] = val;
-    }
-    // convert to dac units
-    else if (LTC2620_VoltageToDac(val, &dacval) == OK) {
-        dacValues[ind] = dacval;
-    }
-#else
-    if (LTC2620_SetDACValue((int)ind, val, mV, &dacval) == OK)
-        dacValues[ind] = dacval;
-#endif
-}
-
-int getDAC(enum DACINDEX ind, int mV) {
-    if (!mV) {
-        LOG(logDEBUG1, ("Getting DAC %d : %d dac\n", ind, dacValues[ind]));
-        return dacValues[ind];
-    }
-    int voltage = -1;
-    LTC2620_DacToVoltage(dacValues[ind], &voltage);
-    LOG(logDEBUG1,
-        ("Getting DAC %d : %d dac (%d mV)\n", ind, dacValues[ind], voltage));
-    return voltage;
-}
-
-int getMaxDacSteps() { return LTC2620_GetMaxNumSteps(); }
-
-int dacToVoltage(int dac) {
-    int val;
-    LTC2620_DacToVoltage(dac, &val);
-    return val;
-}
-
-int checkVLimitCompliant(int mV) {
-    if (vLimit > 0 && mV > vLimit)
+int setADCVpp(int val, int mV, char *mess) {
+    if (AD9257_SetVrefVoltage(val, mV) == FAIL) {
+        sprintf(mess, "Could not set Adc Vpp. Please set a proper value\n");
+        LOG(logERROR, (mess));
         return FAIL;
+    }
+    // cannot validate (just a variable and mv gives different values
     return OK;
 }
 
-int checkVLimitDacCompliant(int dac) {
-    if (vLimit > 0 && dac != -1 && dac != LTC2620_GetPowerDownValue()) {
-        int mv = 0;
-        // could not convert
-        if (LTC2620_DacToVoltage(dac, &mv) == FAIL)
+int getADCVpp(int mV, int *retval, char *mess) {
+    *retval = AD9257_GetVrefVoltage(mV);
+    if (*retval == -1) {
+        sprintf(mess, "Could not get Adc Vpp.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    LOG(logDEBUG1, ("Adc Vpp retval: %d %s\n", *retval, (mV ? "mV" : "mode")));
+    return OK;
+}
+
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    if (ind < 0 || ind >= NDAC) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %d. Input value %d cannot be negative\n",
+                ind, voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %d. Input value %d mV exceeds maximum %d mV\n",
+            ind, voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate vlimit
+    if (vLimit > 0 && voltage > vLimit) {
+        sprintf(mess,
+                "Could not set DAC %d. Input %d mV exceeds vLimit %d mV\n", ind,
+                voltage, vLimit);
+        LOG(logERROR, (mess))
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    *retval_dacval = -1;
+    // normal dacs
+    if (ind < NDAC_ONLY) {
+        if (LTC2620_VoltageToDac(voltage, retval_dacval) == FAIL) {
+            sprintf(
+                mess,
+                "Could not set DAC %d. Could not convert %d mV to dac units.\n",
+                ind, voltage);
+            LOG(logERROR, (mess));
             return FAIL;
-        if (mv > vLimit)
+        }
+        return OK;
+    }
+    // vchip
+    if (ind == D_PWR_CHIP) {
+        if (ConvertToDifferentRange(
+                VCHIP_MIN_MV, VCHIP_MAX_MV, LTC2620_GetMaxInput(),
+                LTC2620_GetMinInput(), voltage, retval_dacval) == FAIL) {
+            sprintf(mess,
+                    "Could not set DAC %d (vchip). Could not convert %d mV to "
+                    "dac units.\n",
+                    ind, voltage);
+            LOG(logERROR, (mess));
+            return FAIL;
+        }
+        return OK;
+    }
+    // power dacs
+    if (ConvertToDifferentRange(POWER_RGLTR_MIN, POWER_RGLTR_MAX,
+                                LTC2620_GetMaxInput(), LTC2620_GetMinInput(),
+                                voltage, retval_dacval) == FAIL) {
+        sprintf(mess,
+                "Could not set DAC %d. Could not convert %d mV to dac units.\n",
+                ind, voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    // normal dacs
+    if (ind < NDAC_ONLY) {
+        if (LTC2620_DacToVoltage(dacval, retval_voltage) == FAIL) {
+            sprintf(
+                mess,
+                "Could not get DAC %d. Could not convert %d dac units to mV\n",
+                ind, dacval);
+            LOG(logERROR, (mess));
+            return FAIL;
+        }
+        return OK;
+    }
+    // vchip
+    if (ind == D_PWR_CHIP) {
+        if (ConvertToDifferentRange(
+                LTC2620_GetMaxInput(), LTC2620_GetMinInput(), VCHIP_MIN_MV,
+                VCHIP_MAX_MV, dacval, retval_voltage) == FAIL) {
+            sprintf(mess,
+                    "Could not get DAC %d (vchip). Could not convert %d dac "
+                    "units to mV\n",
+                    ind, dacval);
+            LOG(logERROR, (mess));
+            return FAIL;
+        }
+        return OK;
+    }
+    // power dacs
+    if (ConvertToDifferentRange(LTC2620_GetMaxInput(), LTC2620_GetMinInput(),
+                                POWER_RGLTR_MIN, POWER_RGLTR_MAX, dacval,
+                                retval_voltage) == FAIL) {
+        sprintf(mess,
+                "Could not get DAC %d. Could not convert %d dac units to mV\n",
+                ind, dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    *retval = -1;
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = dacValues[ind];
+    if (dacval == LTC2620_GetPowerDownValue()) {
+        LOG(logWARNING, ("DAC %d is in power down mode.\n", ind));
+        *retval = dacval;
+        return OK;
+    }
+
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
+    }
+
+    *retval = dacval;
+    return OK;
+}
+
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    LOG(logINFO,
+        ("Setting DAC %d: %d %s \n", ind, val, (mV ? "mV" : "dac units")));
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = val;
+    if (mV) {
+        if (ind < NDAC_ONLY) {
+            if (validateDACVoltage(ind, val, mess) == FAIL)
+                return FAIL;
+        }
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
             return FAIL;
     }
+    {
+        char dacName[20] = {0};
+        snprintf(dacName, sizeof(dacName), "dac %d", ind);
+        if (LTC2620_SetDacValue((int)ind, dacval, dacName, mess) == FAIL)
+            return FAIL;
+    }
+    dacValues[ind] = dacval;
     return OK;
 }
 
 int getVLimit() { return vLimit; }
 
-void setVLimit(int l) {
-    if (l >= 0)
-        vLimit = l;
+int setVLimit(int val, char *mess) {
+    if (val < 0) {
+        sprintf(mess, "Could not set vlimit. Invalid value %d\n", val);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    vLimit = val;
+    return OK;
 }
 
-int isVchipValid(int val) {
+int validateVchip(int val, char *mess) {
     if (val < VCHIP_MIN_MV || val > VCHIP_MAX_MV) {
-        return 0;
+        sprintf(mess,
+                "Invalid vchip value %d mV. Must be between %d and %d mV\n",
+                val, VCHIP_MIN_MV, VCHIP_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    return 1;
+    if (vLimit > 0 && val > vLimit) {
+        sprintf(mess, "Invalid vchip value %d mV. Exceeds vLimit %d mV\n", val,
+                vLimit);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
 }
 
-int getVchip() {
-    // not set yet
-    if (dacValues[D_PWR_CHIP] == -1 ||
-        dacValues[D_PWR_CHIP] == LTC2620_GetPowerDownValue())
-        return dacValues[D_PWR_CHIP];
-    int voltage = -1;
-    // dac to voltage
-    ConvertToDifferentRange(LTC2620_GetMaxInput(), LTC2620_GetMinInput(),
-                            VCHIP_MIN_MV, VCHIP_MAX_MV, dacValues[D_PWR_CHIP],
-                            &voltage);
-    return voltage;
+int getVchip(int *retval, char *mess) {
+    if (getDAC(D_PWR_CHIP, true, retval, mess) == FAIL)
+        return FAIL;
+    LOG(logDEBUG1, ("Vchip: %d\n", *retval));
+    return OK;
 }
 
-void setVchip(int val) {
-    // set vchip
-    if (val != -1) {
-        LOG(logINFOBLUE, ("Setting Vchip to %d mV\n", val));
+int setVchip(int val, char *mess) {
+    LOG(logINFOBLUE, ("Setting Vchip to %d mV\n", val));
+    if (validateVchip(val, mess) == FAIL)
+        return FAIL;
 
-        int dacval = LTC2620_GetPowerDownValue();
+    if (setDAC(D_PWR_CHIP, val, true, mess) == FAIL)
+        return FAIL;
 
-        // validate & convert it to dac
-        if (val != LTC2620_GetPowerDownValue()) {
-            // convert voltage to dac
-            if (ConvertToDifferentRange(
-                    VCHIP_MIN_MV, VCHIP_MAX_MV, LTC2620_GetMaxInput(),
-                    LTC2620_GetMinInput(), // min val is max V
-                    val, &dacval) == FAIL) {
-                LOG(logERROR,
-                    ("\tVChip %d mV invalid. Is not between %d and %d mV\n",
-                     val, VCHIP_MIN_MV, VCHIP_MAX_MV));
-                return;
-            }
-        }
-        LOG(logINFO, ("Setting Vchip (DAC %d): %d dac (%d mV)\n", D_PWR_CHIP,
-                      dacval, val));
-        // set
-        setDAC(D_PWR_CHIP, dacval, 0);
-    }
+    return OK;
 }
 
-int getVChipToSet(enum DACINDEX ind, int val) {
-    LOG(logDEBUG1, ("Calculating vchip to set\n"));
-    // validate index & get adc index
-    int adcIndex = getADCIndexFromDACIndex(ind);
-    if (adcIndex == -1) {
-        return -1;
-    }
-
-    // get maximum value of the adc values (minimum is 0)
+int getVchipToSet(enum DACINDEX ind, int pwr_val, int *retval_vchip,
+                  char *mess) {
+    // get the max of all the power regulators
     int max = 0;
-
-    // loop through the adcs
-    for (int ipwr = 0; ipwr < NPWR - 1; ++ipwr) {
-
-        // get the dac values for each adc
-        int dacmV = getPower(getDACIndexFromADCIndex(ipwr));
-
-        // if current index, replace with value to be set
-        if (ipwr == adcIndex) {
-            dacmV = val;
+    for (int ipwr = NDAC_ONLY; ipwr <= NDAC; ++ipwr) {
+        if (ipwr == D_PWR_CHIP)
+            continue;
+        int val = 0;
+        // current index, use the value to be set
+        if (ipwr == (int)ind) {
+            val = pwr_val;
+        } else {
+            if (getPower(ind, &val, mess) == FAIL)
+                return FAIL;
         }
-
-        // update max
-        max = (dacmV > max) ? dacmV : max;
+        if (val > max)
+            max = val;
     }
-
     // increment to get vchip value
-    max += VCHIP_POWER_INCRMNT;
+    int retval = max + VCHIP_POWER_INCRMNT;
 
-    // validate with vchip minimum value
-    if (max < VCHIP_MIN_MV)
-        max = VCHIP_MIN_MV;
-    // with correct calulations, vchip val should never be greater than vchipmax
-    if (max > VCHIP_MAX_MV) {
-        LOG(logERROR,
-            ("Vchip value to set %d is beyond its maximum (WEIRD)\n", max));
-        return -1;
+    // use min value, dont complain
+    if (retval < VCHIP_MIN_MV)
+        retval = VCHIP_MIN_MV;
+    // max checked earlier, should not happen
+    if (retval > VCHIP_MAX_MV) {
+        enum PWRINDEX pwrIndex = PWR_IO;
+        if (getPowerIndexFromDACIndex(ind, &pwrIndex, mess) == FAIL)
+            return FAIL;
+        char *powerNames[] = {PWR_NAMES};
+        sprintf(
+            mess,
+            "Could not set %s. Vchip value to set %d is beyond itsmaximum %d\n",
+            powerNames[pwrIndex], retval, VCHIP_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    return max;
+    *retval_vchip = retval;
+
+    LOG(logDEBUG1, ("\tVchip to set:%d\n", *retval_vchip));
+    return OK;
 }
 
-int getDACIndexFromADCIndex(enum ADCINDEX ind) {
-    switch (ind) {
-    case V_PWR_IO:
-        return D_PWR_IO;
-    case V_PWR_A:
-        return D_PWR_A;
-    case V_PWR_B:
-        return D_PWR_B;
-    case V_PWR_C:
-        return D_PWR_C;
-    case V_PWR_D:
-        return D_PWR_D;
-    default:
-        LOG(logERROR, ("ADC index %d is not defined to get DAC index\n", ind));
-        return -1;
+int validatePower(enum PWRINDEX ind, int val, char *mess) {
+    char *powerNames[] = {PWR_NAMES};
+    // validate min value
+    int min = (ind == PWR_IO) ? VIO_MIN_MV : POWER_RGLTR_MIN;
+    if (val < min && val != 0) {
+        sprintf(
+            mess,
+            "Could not set %s. Input value %d mV must be greater than %d mV.\n",
+            powerNames[ind], val, min);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
+    // validate max value
+    int max = (VCHIP_MAX_MV - VCHIP_POWER_INCRMNT);
+    if (val > max) {
+        sprintf(
+            mess,
+            "Could not set %s. Input value %d mV must be less than %d mV.\n",
+            powerNames[ind], val, max);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate vlimit
+    if (vLimit > 0 && val > vLimit) {
+        sprintf(mess, "Could not set %s. Input %d mV exceeds vLimit %d mV\n",
+                powerNames[ind], val, vLimit);
+        LOG(logERROR, (mess))
+        return FAIL;
+    }
+    return OK;
 }
 
-int getADCIndexFromDACIndex(enum DACINDEX ind) {
+// for power rail index and name debugging
+int getPowerIndexFromDACIndex(enum DACINDEX ind, enum PWRINDEX *pwrIndex,
+                              char *mess) {
+    *pwrIndex = PWR_IO;
     switch (ind) {
     case D_PWR_IO:
-        return V_PWR_IO;
+        *pwrIndex = PWR_IO;
+        break;
     case D_PWR_A:
-        return V_PWR_A;
+        *pwrIndex = PWR_A;
+        break;
     case D_PWR_B:
-        return V_PWR_B;
+        *pwrIndex = PWR_B;
+        break;
     case D_PWR_C:
-        return V_PWR_C;
+        *pwrIndex = PWR_C;
+        break;
     case D_PWR_D:
-        return V_PWR_D;
+        *pwrIndex = PWR_D;
+        break;
     default:
-        LOG(logERROR, ("DAC index %d is not defined to get ADC index\n", ind));
-        return -1;
+        sprintf(mess, "Index %d has no power index\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
+    return OK;
 }
 
-int isPowerValid(enum DACINDEX ind, int val) {
-    int min = (ind == D_PWR_IO) ? VIO_MIN_MV : POWER_RGLTR_MIN;
-
-    // not power_rgltr_max because it is allowed only upto vchip max - 200
-    if (val != 0 && (val != LTC2620_GetPowerDownValue()) &&
-        (val < min || val > (VCHIP_MAX_MV - VCHIP_POWER_INCRMNT))) {
-        return 0;
+int getPowerRailMask(enum PWRINDEX ind, uint32_t *mask, char *mess) {
+    *mask = 0;
+    switch (ind) {
+    case PWR_IO:
+        *mask = POWER_ENBL_VIO_MSK;
+        break;
+    case PWR_A:
+        *mask = POWER_ENBL_VA_MSK;
+        break;
+    case PWR_B:
+        *mask = POWER_ENBL_VB_MSK;
+        break;
+    case PWR_C:
+        *mask = POWER_ENBL_VC_MSK;
+        break;
+    case PWR_D:
+        *mask = POWER_ENBL_VD_MSK;
+        break;
+    default:
+        sprintf(mess, "Index %d has no power rail index\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    return 1;
+    return OK;
 }
 
-int getPower(enum DACINDEX ind) {
-    // validate index & get adc index
-    int adcIndex = getADCIndexFromDACIndex(ind);
-    if (adcIndex == -1) {
-        return -1;
-    }
-
-    // powered enable off
-    {
-        uint32_t addr = POWER_REG;
-        uint32_t offset = POWER_ENBL_VLTG_RGLTR_OFST + adcIndex;
-        uint32_t mask = (1 << offset);
-        if (!(bus_r(addr) & mask))
-            return 0;
-    }
-
-    // not set yet
-    if (dacValues[ind] == -1) {
-        LOG(logERROR,
-            ("Power enabled, but unknown dac value for power index %d!", ind));
-        return -1;
-    }
-
-    // dac powered off
-    if (dacValues[ind] == LTC2620_GetPowerDownValue()) {
-        LOG(logWARNING,
-            ("Power %d enabled, dac value %d, voltage at minimum or 0\n", ind,
-             LTC2620_GetPowerDownValue()));
-        return LTC2620_GetPowerDownValue();
-    }
-
-    // vchip not set, weird error, should not happen (as vchip set to max in the
-    // beginning) unless user set vchip to LTC2620_GetPowerDownValue()  and then
-    // tried to get a power regulator value
-    if (dacValues[D_PWR_CHIP] == -1 ||
-        dacValues[D_PWR_CHIP] == LTC2620_GetPowerDownValue()) {
-        LOG(logERROR, ("Cannot read power regulator %d (vchip not set)."
-                       "Set a power regulator, which will also set vchip.\n"));
-        return -1;
-    }
-
-    // convert dac to voltage
-    int retval = -1;
-    ConvertToDifferentRange(LTC2620_GetMaxInput(), LTC2620_GetMinInput(),
-                            POWER_RGLTR_MIN, POWER_RGLTR_MAX, dacValues[ind],
-                            &retval);
-    return retval;
-}
-
-void setPower(enum DACINDEX ind, int val) {
-    // validate index & get adc index
-    int adcIndex = getADCIndexFromDACIndex(ind);
-    if (adcIndex == -1) {
-        return;
-    }
-
+int EnablePowerRail(enum PWRINDEX ind, char *mess) {
+    char *powerNames[] = {PWR_NAMES};
     uint32_t addr = POWER_REG;
-    uint32_t offset = POWER_ENBL_VLTG_RGLTR_OFST + adcIndex;
-    uint32_t mask = (1 << offset);
+    uint32_t mask = 0;
 
-    // set power
-    if (val != -1) {
-        LOG(logINFO, ("Setting Power to %d mV\n", val));
+    if (getPowerRailMask(ind, &mask, mess) == FAIL)
+        return FAIL;
 
-        // validate value (already checked at tcp)
-        if (!isPowerValid(ind, val)) {
-            LOG(logERROR,
-                ("Invalid value of %d mV for Power %d. Is not between %d and "
-                 "%d mV\n",
-                 val, ind, (ind == D_PWR_IO ? VIO_MIN_MV : POWER_RGLTR_MIN),
-                 POWER_RGLTR_MAX));
-            return;
-        }
+    LOG(logINFO, ("\tSwitching on power for %s\n", powerNames[ind]));
+    bus_w(addr, bus_r(addr) | mask);
+    return OK;
+}
 
-        // get vchip to set vchip (calculated now before switching off power
-        // enable)
-        int vchip = getVChipToSet(ind, val);
-        LOG(logDEBUG1, ("Vchip to set: %d\n", vchip));
-        // index problem of vchip calculation problem
-        if (vchip == -1)
-            return;
+int DisablePowerRail(enum PWRINDEX ind, char *mess) {
+    char *powerNames[] = {PWR_NAMES};
+    uint32_t addr = POWER_REG;
+    uint32_t mask = 0;
 
-        // Switch off power enable
-        LOG(logDEBUG1, ("Switching off power enable\n"));
-        bus_w(addr, bus_r(addr) & ~(mask));
+    if (getPowerRailMask(ind, &mask, mess) == FAIL)
+        return FAIL;
 
-        // power down dac
-        LOG(logDEBUG1, ("Powering off P%d (DAC %d)\n", adcIndex, ind));
-        setDAC(ind, LTC2620_GetPowerDownValue(), 0);
+    LOG(logINFO, ("\tSwitching off power for %s\n", powerNames[ind]));
+    bus_w(addr, bus_r(addr) & ~(mask));
+    return OK;
+}
 
-        // set vchip
-        setVchip(vchip);
-        if (getVchip() != vchip) {
-            LOG(logERROR, ("Weird, Could not set vchip. Set %d, read %d\n.",
-                           vchip, getVchip()));
-            return;
-        }
+int getPowerRail(enum PWRINDEX ind, int *retval, char *mess) {
+    char *powerNames[] = {PWR_NAMES};
+    uint32_t addr = POWER_REG;
+    uint32_t mask = 0;
 
-        //(power off is anyway done with power enable)
-        if (val == 0)
-            val = LTC2620_GetPowerDownValue();
+    if (getPowerRailMask(ind, &mask, mess) == FAIL)
+        return FAIL;
 
-        // convert it to dac (power off is anyway done with power enable)
-        if (val != LTC2620_GetPowerDownValue()) {
-            LOG(logDEBUG1, ("Convert Power of %d mV to dac units\n", val));
+    *retval = (bus_r(addr) & mask);
+    LOG(logDEBUG1, ("Power rail retval for %s: %s\n", powerNames[ind],
+                    ((*retval > 0) ? "Enabled" : "Disabled")));
 
-            int dacval = -1;
-            // convert voltage to dac
-            if (ConvertToDifferentRange(
-                    POWER_RGLTR_MIN, POWER_RGLTR_MAX, LTC2620_GetMaxInput(),
-                    LTC2620_GetMinInput(), val, &dacval) == FAIL) {
-                LOG(logERROR,
-                    ("\tPower index %d of value %d mV invalid. Is not between "
-                     "%d and %d mV\n",
-                     ind, val, POWER_RGLTR_MIN, vchip - VCHIP_POWER_INCRMNT));
-                return;
-            }
+    return OK;
+}
 
-            // set and power on/ update dac
-            LOG(logINFO, ("Setting P%d (DAC %d): %d dac (%d mV)\n", adcIndex,
-                          ind, dacval, val));
-            setDAC(ind, dacval, 0);
+int getPower(enum DACINDEX ind, int *retval, char *mess) {
+    enum PWRINDEX pwrIndex = PWR_IO;
+    if (getPowerIndexFromDACIndex(ind, &pwrIndex, mess) == FAIL)
+        return FAIL;
 
-            // to be sure of valid conversion
-            if (dacval >= 0) {
-                LOG(logDEBUG1, ("Switching on power enable\n"));
-                bus_w(addr, bus_r(addr) | mask);
-            }
-        }
+    // if powered off, return 0
+    if (getPowerRail(pwrIndex, retval, mess) == FAIL)
+        return FAIL;
+    if (*retval == 0) {
+        return OK;
     }
+
+    if (getDAC(ind, true, retval, mess) == FAIL)
+        return FAIL;
+    return OK;
+}
+
+int setPower(enum DACINDEX ind, int val, char *mess) {
+    enum PWRINDEX pwrIndex = PWR_IO;
+    if (getPowerIndexFromDACIndex(ind, &pwrIndex, mess) == FAIL)
+        return FAIL;
+
+    char *powerNames[] = {PWR_NAMES};
+    LOG(logINFOBLUE, ("Setting %s to %d mV\n", powerNames[pwrIndex], val));
+
+    if (validatePower(pwrIndex, val, mess) == FAIL)
+        return FAIL;
+
+    // compute vchip to set before powering off
+    int vchip = 0;
+    if (getVchipToSet(ind, val, &vchip, mess) == FAIL)
+        return FAIL;
+
+    if (DisablePowerRail(pwrIndex, mess) == FAIL)
+        return FAIL;
+
+    if (setVchip(vchip, mess) == FAIL)
+        return FAIL;
+
+    if (val != 0) {
+        if (setDAC(ind, val, true, mess) == FAIL)
+            return FAIL;
+
+        if (EnablePowerRail(pwrIndex, mess) == FAIL)
+            return FAIL;
+    }
+    return OK;
 }
 
 void powerOff() {
     uint32_t addr = POWER_REG;
     LOG(logINFO, ("Powering off all voltage regulators\n"));
     bus_w(addr, bus_r(addr) & (~POWER_ENBL_VLTG_RGLTR_MSK));
-    LOG(logDEBUG1, ("Power Register: 0x%08x\n", bus_r(addr)));
 }
 
 int getADC(enum ADCINDEX ind) {
@@ -1720,24 +1858,33 @@ int getSlowADCTemperature() {
     return tempValue;
 }
 
-int setHighVoltage(int val) {
-    // setting hv
-    if (val >= 0) {
-        LOG(logINFO, ("Setting High voltage: %d V\n", val));
-        uint32_t addr = POWER_REG;
-
-        // switch to external high voltage
-        bus_w(addr, bus_r(addr) & (~POWER_HV_INTERNAL_SLCT_MSK));
-
-        MAX1932_Set(&val);
-
-        // switch on internal high voltage, if set
-        if (val > 0)
-            bus_w(addr, bus_r(addr) | POWER_HV_INTERNAL_SLCT_MSK);
-
-        highvoltage = val;
+int setHighVoltage(int val, char *mess) {
+    if (val < 0) {
+        sprintf(mess, "Could not set high voltage. Invalid value:%d\n", val);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    return highvoltage;
+    LOG(logINFO, ("Setting High voltage: %d V\n", val));
+    uint32_t addr = POWER_REG;
+
+    // switch to external high voltage
+    bus_w(addr, bus_r(addr) & (~POWER_HV_INTERNAL_SLCT_MSK));
+
+    if (MAX1932_Set(val, mess) == FAIL)
+        return FAIL;
+
+    // switch on internal high voltage, if set
+    if (val > 0)
+        bus_w(addr, bus_r(addr) | POWER_HV_INTERNAL_SLCT_MSK);
+
+    highvoltage = val;
+    return OK;
+}
+
+int getHighVoltage(int *retval, char *mess) {
+    LOG(logDEBUG1, ("High Voltage: %d\n", *retval));
+    *retval = highvoltage;
+    return OK;
 }
 
 /* parameters - timing, extsig */

slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.h

@@ -7,6 +7,7 @@
 #include "blackfin.h"
 #include "programViaBlackfin.h"
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -123,31 +124,44 @@ enum detectorSettings getSettings();
 
 // parameters - threshold
 // parameters - dac, adc, hv
+int setADCVpp(int val, int mV, char *mess);
+int getADCVpp(int mV, int *retval, char *mess);
+
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
 
-void setDAC(enum DACINDEX ind, int val, int mV);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
-int dacToVoltage(int dac);
-int checkVLimitCompliant(int mV);
-int checkVLimitDacCompliant(int dac);
 int getVLimit();
-void setVLimit(int l);
+int setVLimit(int val, char *mess);
 
-int isVchipValid(int val);
-int getVchip();
-void setVchip(int val);
-int getVChipToSet(enum DACINDEX ind, int val);
-int getDACIndexFromADCIndex(enum ADCINDEX ind);
-int getADCIndexFromDACIndex(enum DACINDEX ind);
-int isPowerValid(enum DACINDEX ind, int val);
-int getPower();
-void setPower(enum DACINDEX ind, int val);
+int validateVchip(int val, char *mess);
+int getVchip(int *retval, char *mess);
+int setVchip(int val, char *mess);
+int getVchipToSet(enum DACINDEX ind, int pwr_val, int *retval_vchip,
+                  char *mess);
+
+int validatePower(enum PWRINDEX ind, int val, char *mess);
+int getPowerIndexFromDACIndex(enum DACINDEX ind, enum PWRINDEX *pwrIndex,
+                              char *mess);
+int getPowerRailMask(enum PWRINDEX ind, uint32_t *mask, char *mess);
+int EnablePowerRail(enum PWRINDEX ind, char *mess);
+int DisablePowerRail(enum PWRINDEX ind, char *mess);
+int getPowerRail(enum PWRINDEX ind, int *retval, char *mess);
+int getPower(enum DACINDEX ind, int *retval, char *mess);
+int setPower(enum DACINDEX ind, int val, char *mess);
 void powerOff();
 
 int getADC(enum ADCINDEX ind);
 int getSlowADC(int ichan);
 int getSlowADCTemperature();
-int setHighVoltage(int val);
+int setHighVoltage(int val, char *mess);
+int getHighVoltage(int *retval, char *mess);
 
 // parameters - timing, extsig
 

slsDetectorServers/ctbDetectorServer/slsDetectorServer_defs.h

@@ -173,5 +173,9 @@ enum DACINDEX {
     D_PWR_A,
     D_PWR_IO
 };
+
+enum PWRINDEX { PWR_IO, PWR_A, PWR_B, PWR_C, PWR_D };
+#define PWR_NAMES "VIO", "VA", "VB", "VC", "VD"
+
 enum CLKINDEX { RUN_CLK, ADC_CLK, SYNC_CLK, DBIT_CLK, NUM_CLOCKS };
 #define CLK_NAMES "run", "adc", "sync", "dbit"

slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c

@@ -54,7 +54,6 @@ int top = 0;
 int master = 0;
 int normal = 0;
 
-int eiger_highvoltage = 0;
 int eiger_theo_highvoltage = 0;
 int eiger_iodelay = 0;
 int eiger_dynamicrange = 0;
@@ -800,7 +799,9 @@ void setupDetector() {
         return;
 
     LOG(logINFOBLUE, ("Setting Default Parameters\n"));
-    resetToDefaultDacs(0);
+    initError = resetToDefaultDacs(0, initErrorMessage);
+    if (initError == FAIL)
+        return;
 #ifdef VIRTUAL
     if (isControlServer) {
         sharedMemory_setStatus(IDLE);
@@ -836,7 +837,10 @@ void setupDetector() {
     Feb_Control_SetInTestModeVariable(DEFAULT_TEST_MODE);
     sharedMemory_unlockLocalLink();
 #endif
-    setHighVoltage(DEFAULT_HIGH_VOLTAGE);
+    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE, initErrorMessage);
+    if (initError == FAIL)
+        return;
+
 #ifndef VIRTUAL
     sharedMemory_lockLocalLink();
     if (!Feb_Control_CheckSetup()) {
@@ -863,7 +867,7 @@ void setupDetector() {
     LOG(logDEBUG1, ("Setup detector done\n\n"));
 }
 
-int resetToDefaultDacs(int hardReset) {
+int resetToDefaultDacs(int hardReset, char *mess) {
     // reset defaults to hardcoded defaults
     if (hardReset) {
         const int vals[] = DEFAULT_DAC_VALS;
@@ -875,12 +879,8 @@ int resetToDefaultDacs(int hardReset) {
     int ret = OK;
     LOG(logINFOBLUE, ("Setting Default Dac values\n"));
     for (int i = 0; i < NDAC; ++i) {
-        setDAC((enum DACINDEX)i, defaultDacValues[i], 0);
-        if ((detectorModules)->dacs[i] != defaultDacValues[i]) {
-            ret = FAIL;
-            LOG(logERROR, ("Setting dac %d failed, wrote %d, read %d\n", i,
-                           defaultDacValues[i], (detectorModules)->dacs[i]));
-        }
+        if (setDAC((enum DACINDEX)i, defaultDacValues[i], false, mess) == FAIL)
+            return FAIL;
     }
     return ret;
 }
@@ -1304,14 +1304,15 @@ int setModule(sls_detector_module myMod, char *mess) {
     detectorModules->serialnumber = myMod.serialnumber;
 
     // settings
-    setSettings((enum detectorSettings)myMod.reg);
+    if (setSettings((enum detectorSettings)myMod.reg, mess) == FAIL)
+        return FAIL;
 
     // iodelay
     if (setIODelay(myMod.iodelay) != myMod.iodelay) {
         sprintf(mess, "Could not set module. Could not set iodelay %d\n",
                 myMod.iodelay);
         LOG(logERROR, (mess));
-        setSettings(UNDEFINED);
+        setSettings(UNDEFINED, mess);
         LOG(logERROR, ("Settings has been changed to undefined\n"));
         return FAIL;
     }
@@ -1321,18 +1322,19 @@ int setModule(sls_detector_module myMod, char *mess) {
         setThresholdEnergy(myMod.eV[0]);
     else {
         // (loading a random trim file) (dont return fail)
-        setSettings(UNDEFINED);
+        setSettings(UNDEFINED, mess);
         LOG(logERROR,
             ("Settings has been changed to undefined (random trim file)\n"));
     }
 
     // dacs
     for (int i = 0; i < NDAC; ++i) {
-        setDAC((enum DACINDEX)i, myMod.dacs[i], 0);
+        if (setDAC((enum DACINDEX)i, myMod.dacs[i], false, mess) == FAIL)
+            return FAIL;
         if (myMod.dacs[i] != (detectorModules)->dacs[i]) {
             sprintf(mess, "Could not set module. Could not set dac %d\n", i);
             LOG(logERROR, (mess));
-            setSettings(UNDEFINED);
+            setSettings(UNDEFINED, mess);
             LOG(logERROR, ("Settings has been changed to undefined\n"));
             return FAIL;
         }
@@ -1359,7 +1361,7 @@ int setModule(sls_detector_module myMod, char *mess) {
                     "Cannot set module. Cannot set Rate correction. "
                     "No default tau provided. Deactivating Rate Correction\n");
             LOG(logERROR, (mess));
-            setSettings(UNDEFINED);
+            setSettings(UNDEFINED, mess);
             LOG(logERROR, ("Settings has been changed to undefined (random "
                            "trim file)\n"));
             return FAIL;
@@ -1372,7 +1374,7 @@ int setModule(sls_detector_module myMod, char *mess) {
             if (setRateCorrection(myMod.tau) == FAIL) {
                 sprintf(mess, "Cannot set module. Rate correction failed.\n");
                 LOG(logERROR, (mess));
-                setSettings(UNDEFINED);
+                setSettings(UNDEFINED, mess);
                 LOG(logERROR, ("Settings has been changed to undefined (random "
                                "trim file)\n"));
                 return FAIL;
@@ -1383,7 +1385,7 @@ int setModule(sls_detector_module myMod, char *mess) {
                         mess,
                         "Cannot set module. Could not set rate correction\n");
                     LOG(logERROR, (mess));
-                    setSettings(UNDEFINED);
+                    setSettings(UNDEFINED, mess);
                     LOG(logERROR, ("Settings has been changed to undefined "
                                    "(random trim file)\n"));
                     return FAIL;
@@ -1394,14 +1396,16 @@ int setModule(sls_detector_module myMod, char *mess) {
     return OK;
 }
 
-enum detectorSettings setSettings(enum detectorSettings sett) {
+int setSettings(enum detectorSettings sett, char *mess) {
     if (sett == UNINITIALIZED) {
-        return thisSettings;
+        sprintf(mess, "Cannot set settings to uninitialized\n");
+        LOG(logERROR, (mess));
+        return FAIL;
     }
     thisSettings = sett;
     detectorModules->reg = sett;
     LOG(logINFO, ("Settings: %d\n", thisSettings));
-    return thisSettings;
+    return OK;
 }
 
 enum detectorSettings getSettings() { return thisSettings; }
@@ -1422,100 +1426,163 @@ int setThresholdEnergy(int ev) {
 }
 
 /* parameters - dac, adc, hv */
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    // including E_VTHRESHOLD
+    if (ind < 0 || ind >= NDAC + 1) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    char *dacNames[] = {DAC_NAMES};
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %s. Input value %d cannot be negative\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %s. Input value %d mV exceeds maximum %d mV\n",
+            dacNames[ind], voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    char *dacNames[] = {DAC_NAMES};
+    if (ConvertToDifferentRange(DAC_MIN_MV, DAC_MAX_MV, LTC2620_MIN_VAL,
+                                LTC2620_MAX_VAL, voltage,
+                                retval_dacval) == FAIL) {
+        sprintf(mess,
+                "Could not set DAC %s. Could not convert %d mV to dac units.\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    if (ConvertToDifferentRange(LTC2620_MIN_VAL, LTC2620_MAX_VAL, DAC_MIN_MV,
+                                DAC_MAX_MV, dacval, retval_voltage) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not set DAC %s. Could not convert %d mV to dac units.\n",
+                dacNames[ind], dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    if (ind == E_VTHRESHOLD) {
+        return getThresholdDACs(mV, retval, mess);
+    }
+
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = (detectorModules)->dacs[ind];
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
+    }
+
+    *retval = dacval;
+    return OK;
+}
 
 // uses LTC2620 with 2.048V (implementation different to others not bit banging)
-void setDAC(enum DACINDEX ind, int val, int mV) {
-    if (val < 0)
-        return;
-
-    LOG(logDEBUG1, ("Setting dac[%d]: %d %s \n", (int)ind, val,
-                    (mV ? "mV" : "dac units")));
-
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    {
+        char *dacNames[] = {DAC_NAMES};
+        LOG(logINFO, ("Setting DAC %s: %d %s \n", dacNames[ind], val,
+                      (mV ? "mV" : "dac units")));
+    }
     if (ind == E_VTHRESHOLD) {
-        setDAC(E_VCMP_LL, val, mV);
-        setDAC(E_VCMP_LR, val, mV);
-        setDAC(E_VCMP_RL, val, mV);
-        setDAC(E_VCMP_RR, val, mV);
-        setDAC(E_VCP, val, mV);
-        return;
+        return setThresholdDACs(val, mV, mess);
     }
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
 
-    // validate index
-    if (ind < 0 || ind >= NDAC) {
-        LOG(logERROR,
-            ("\tDac index %d is out of bounds (0 to %d)\n", ind, NDAC - 1));
-        return;
-    }
-
-    char *dac_names[] = {DAC_NAMES};
-    LOG(logINFO, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                  val, (mV ? "mV" : "dac units")));
-
-#ifdef VIRTUAL
-    int dacval = 0;
-    if (!mV) {
-        (detectorModules)->dacs[ind] = val;
-    }
-    // convert to dac units
-    else if (ConvertToDifferentRange(DAC_MIN_MV, DAC_MAX_MV, LTC2620_MIN_VAL,
-                                     LTC2620_MAX_VAL, val, &dacval) == OK) {
-        (detectorModules)->dacs[ind] = dacval;
-    }
-#else
     int dacval = val;
     if (mV) {
-        // convert to dac units
-        if (ConvertToDifferentRange(DAC_MIN_MV, DAC_MAX_MV, LTC2620_MIN_VAL,
-                                    LTC2620_MAX_VAL, val, &dacval) == FAIL) {
-            LOG(logERROR,
-                ("Could not convert %d mV for dac to dac units\n", val));
-            return;
-        }
+        if (validateDACVoltage(ind, val, mess) == FAIL)
+            return FAIL;
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
+            return FAIL;
     }
+
+#ifdef VIRTUAL
+    (detectorModules)->dacs[ind] = dacval;
+    return OK;
+#else
     sharedMemory_lockLocalLink();
-    if (Feb_Control_SetDAC(ind, dacval)) {
-        (detectorModules)->dacs[ind] = dacval;
+    if (!Feb_Control_SetDAC(ind, dacval)) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess, "Could not set DAC %s. Trouble writing to register\n",
+                dacNames[ind]);
+        LOG(logERROR, (mess));
+        sharedMemory_unlockLocalLink();
+        return FAIL;
     }
+    (detectorModules)->dacs[ind] = dacval;
     sharedMemory_unlockLocalLink();
+    return OK;
 #endif
 }
 
-int getDAC(enum DACINDEX ind, int mV) {
-    if (ind == E_VTHRESHOLD) {
-        int ret[5] = {0};
-        ret[0] = getDAC(E_VCMP_LL, mV);
-        ret[1] = getDAC(E_VCMP_LR, mV);
-        ret[2] = getDAC(E_VCMP_RL, mV);
-        ret[3] = getDAC(E_VCMP_RR, mV);
-        ret[4] = getDAC(E_VCP, mV);
-
-        if ((ret[0] == ret[1]) && (ret[1] == ret[2]) && (ret[2] == ret[3]) &&
-            (ret[3] == ret[4])) {
-            LOG(logINFO, ("\tvthreshold match\n"));
-            return ret[0];
-        } else {
-            LOG(logERROR, ("\tvthreshold mismatch vcmp_ll:%d vcmp_lr:%d "
-                           "vcmp_rl:%d vcmp_rr:%d vcp:%d\n",
-                           ret[0], ret[1], ret[2], ret[3], ret[4]));
-            return -1;
-        }
+int setThresholdDACs(int val, bool mV, char *mess) {
+    enum DACINDEX indices[5] = {E_VCMP_LL, E_VCMP_LR, E_VCMP_RL, E_VCMP_RR,
+                                E_VCP};
+    for (int i = 0; i != 5; ++i) {
+        if (setDAC(indices[i], val, mV, mess) == FAIL)
+            return FAIL;
     }
-
-    if (!mV) {
-        LOG(logDEBUG1,
-            ("Getting DAC %d : %d dac\n", ind, (detectorModules)->dacs[ind]));
-        return (detectorModules)->dacs[ind];
-    }
-    int voltage = -1;
-    // dac units to voltage
-    ConvertToDifferentRange(LTC2620_MIN_VAL, LTC2620_MAX_VAL, DAC_MIN_MV,
-                            DAC_MAX_MV, (detectorModules)->dacs[ind], &voltage);
-    LOG(logDEBUG1, ("Getting DAC %d : %d dac (%d mV)\n", ind,
-                    (detectorModules)->dacs[ind], voltage));
-    return voltage;
+    return OK;
 }
 
-int getMaxDacSteps() { return DAC_MAX_STEPS; }
+int getThresholdDACs(bool mV, int *retval, char *mess) {
+    enum DACINDEX indices[5] = {E_VCMP_LL, E_VCMP_LR, E_VCMP_RL, E_VCMP_RR,
+                                E_VCP};
+    int retvals[5] = {0};
+    *retval = -1; // default to mismatch
+
+    for (int i = 0; i != 5; ++i) {
+        if (getDAC(indices[i], mV, &retvals[i], mess) == FAIL)
+            return FAIL;
+        // set retval to first value
+        if (*retval == -1) {
+            *retval = retvals[i];
+        }
+        // other values should match the first value
+        else if (retvals[i] != retvals[0]) {
+            char *dacNames[] = {DAC_NAMES};
+            LOG(logWARNING,
+                ("Vthreshold mismatch.%s:%d %s:%d\n", dacNames[indices[i]],
+                 retvals[i], dacNames[indices[0]], retvals[0]));
+            *retval = -1;
+            return OK;
+        }
+    }
+    LOG(logINFO, ("\tvthreshold match %d\n", *retval));
+    return OK;
+}
 
 int getADC(enum ADCINDEX ind) {
 #ifdef VIRTUAL
@@ -1563,61 +1630,86 @@ int getADC(enum ADCINDEX ind) {
 #endif
 }
 
-int setHighVoltage(int val) {
+int getHighVoltage(int *retval, char *mess) {
+    if (!master) {
+        LOG(logDEBUG1, ("High Voltage: %d\n", SLAVE_HIGH_VOLTAGE_READ_VAL));
+        *retval = SLAVE_HIGH_VOLTAGE_READ_VAL;
+        return OK;
+    }
+
+    // master
 #ifdef VIRTUAL
-    if (master) {
-        // set
-        if (val != -1) {
-            LOG(logINFO, ("Setting High voltage: %d V\n", val));
-            eiger_theo_highvoltage = val;
-        }
-        return eiger_theo_highvoltage;
-    }
-
-    return SLAVE_HIGH_VOLTAGE_READ_VAL;
+    LOG(logDEBUG1, ("High Voltage: %d\n", eiger_theo_highvoltage));
+    *retval = eiger_theo_highvoltage;
+    return OK;
 #else
-
-    if (master) {
-
-        // set
-        if (val != -1) {
-            eiger_theo_highvoltage = val;
-            sharedMemory_lockLocalLink();
-            int ret = Feb_Control_SetHighVoltage(val);
-            sharedMemory_unlockLocalLink();
-            if (!ret) // could not set
-                return -2;
-            else if (ret == -1) // outside range
-                return -1;
-        }
-
-        // get
-        sharedMemory_lockLocalLink();
-        if (!Feb_Control_GetHighVoltage(&eiger_highvoltage)) {
-            LOG(logERROR, ("Could not read high voltage\n"));
-            sharedMemory_unlockLocalLink();
-            return -3;
-        }
-        // need to read the file twice to get the proper value
-        if (!Feb_Control_GetHighVoltage(&eiger_highvoltage)) {
-            LOG(logERROR, ("Could not read high voltage\n"));
-            sharedMemory_unlockLocalLink();
-            return -3;
-        }
+    // get
+    int eiger_highvoltage = 0;
+    sharedMemory_lockLocalLink();
+    if (!Feb_Control_GetHighVoltage(&eiger_highvoltage)) {
+        LOG(logERROR, ("Could not read high voltage\n"));
         sharedMemory_unlockLocalLink();
+        strcpy(
+            mess,
+            "Getting high voltage failed. Serial/i2c communication failed.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // need to read the file twice to get the proper value
+    if (!Feb_Control_GetHighVoltage(&eiger_highvoltage)) {
+        LOG(logERROR, ("Could not read high voltage\n"));
+        sharedMemory_unlockLocalLink();
+        strcpy(
+            mess,
+            "Getting high voltage failed. Serial/i2c communication failed.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    sharedMemory_unlockLocalLink();
 
-        // tolerance of 5
-        if (abs(eiger_theo_highvoltage - eiger_highvoltage) >
-            HIGH_VOLTAGE_TOLERANCE) {
-            LOG(logINFO,
-                ("High voltage still ramping: %d\n", eiger_highvoltage));
-            return eiger_highvoltage;
-        }
-        return eiger_theo_highvoltage;
+    // tolerance of 5
+    if (abs(eiger_theo_highvoltage - eiger_highvoltage) >
+        HIGH_VOLTAGE_TOLERANCE) {
+        LOG(logINFO, ("High voltage still ramping: %d\n", eiger_highvoltage));
+        *retval = eiger_highvoltage;
+        LOG(logDEBUG1, ("High Voltage: %d\n", eiger_highvoltage));
+        return OK;
+    }
+    *retval = eiger_theo_highvoltage;
+    LOG(logDEBUG1, ("High Voltage: %d\n", eiger_theo_highvoltage));
+    return OK;
+#endif
+}
+
+int setHighVoltage(int val, char *mess) {
+#ifdef VIRTUAL
+    LOG(logINFO, ("Setting High voltage: %d V\n", val));
+    eiger_theo_highvoltage = val;
+#else
+    eiger_theo_highvoltage = val;
+    sharedMemory_lockLocalLink();
+    int ret = Feb_Control_SetHighVoltage(val);
+    sharedMemory_unlockLocalLink();
+
+    if (ret == 0) {
+        strcpy(
+            mess,
+            "Setting high voltage failed. Serial/i2c communication failed.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    if (ret == -1) {
+        sprintf(mess,
+                "Setting high voltage failed. Invalid input %d. The range is "
+                "from 0 to 200 V.\n",
+                val);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
-    return SLAVE_HIGH_VOLTAGE_READ_VAL;
+    // cannot validate using get
 #endif
+    return OK;
 }
 
 /* parameters - timing, extsig */
@@ -2138,7 +2230,7 @@ int validateAndSetRateCorrection(int64_t tau_ns, char *mess) {
     }
     // user defined value (settings become undefined)
     else if (tau_ns > 0) {
-        setSettings(UNDEFINED);
+        setSettings(UNDEFINED, mess);
         LOG(logERROR,
             ("Settings has been changed to undefined (tau changed)\n"));
         eiger_tau_ns = tau_ns;
@@ -2341,7 +2433,7 @@ int setTrimbits(int *chanregs, char *mess) {
     if (!Feb_Control_SetTrimbits(tt, top)) {
         sprintf(mess, "Could not set module. Could not set trimbits\n");
         LOG(logERROR, (mess));
-        setSettings(UNDEFINED);
+        setSettings(UNDEFINED, mess);
         LOG(logERROR, ("Settings has been changed to undefined (random "
                        "trim file)\n"));
 

slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.h

@@ -3,6 +3,7 @@
 #include "sls/sls_detector_defs.h"
 #include "slsDetectorServer_defs.h" // DAC_INDEX, ADC_INDEX, also include RegisterDefs.h
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -69,7 +70,7 @@ void setupFebBeb();
 int allocateDetectorStructureMemory();
 void setupDetector();
 
-int resetToDefaultDacs(int hardReset);
+int resetToDefaultDacs(int hardReset, char *mess);
 int getDefaultDac(enum DACINDEX index, enum detectorSettings sett, int *retval);
 int setDefaultDac(enum DACINDEX index, enum detectorSettings sett, int value);
 int readConfigFile();
@@ -115,7 +116,7 @@ int64_t getMeasuredSubPeriod();
 void getModule(sls_detector_module *myMod);
 int setModule(sls_detector_module myMod, char *mess);
 int setTrimbits(int *chanregs, char *mess);
-enum detectorSettings setSettings(enum detectorSettings sett);
+int setSettings(enum detectorSettings sett, char *mess);
 enum detectorSettings getSettings();
 
 // parameters - threshold
@@ -123,12 +124,22 @@ int getThresholdEnergy();
 int setThresholdEnergy(int ev);
 
 // parameters - dac, adc, hv
-void setDAC(enum DACINDEX ind, int val, int mV);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
+
+int setThresholdDACs(int val, bool mV, char *mess);
+int getThresholdDACs(bool mV, int *retval, char *mess);
 
 int getADC(enum ADCINDEX ind);
-int setHighVoltage(int val);
+int setHighVoltage(int val, char *mess);
+int getHighVoltage(int *retval, char *mess);
 
 // parameters - timing, extsig
 int setMaster(enum MASTERINDEX m);

slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c

@@ -479,10 +479,8 @@ void setupDetector() {
     setTimingSource(DEFAULT_TIMING_SOURCE);
 
     // Default values
-    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE);
+    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE, initErrorMessage);
     if (initError == FAIL) {
-        sprintf(initErrorMessage, "Could not set high voltage to %d\n",
-                DEFAULT_HIGH_VOLTAGE);
         return;
     }
 
@@ -524,7 +522,9 @@ void setupDetector() {
     setBurstMode(DEFAULT_BURST_MODE);
     setFilterResistor(DEFAULT_FILTER_RESISTOR);
     setCDSGain(DEFAILT_CDS_GAIN);
-    setSettings(DEFAULT_SETTINGS);
+    initError = setSettings(DEFAULT_SETTINGS, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     // Initialization of acquistion parameters
     setNextFrameNumber(DEFAULT_FRAME_NUMBER);
@@ -560,7 +560,7 @@ void setASICDefaults() {
     LOG(logINFO, ("Setting ASIC Defaults (0x%x)\n", bus_r(addr)));
 }
 
-int resetToDefaultDacs(int hardReset) {
+int resetToDefaultDacs(int hardReset, char *mess) {
     // reset defaults to hardcoded defaults
     if (hardReset) {
         for (int i = 0; i < NDAC; ++i) {
@@ -568,16 +568,12 @@ int resetToDefaultDacs(int hardReset) {
         }
     }
     // reset dacs to defaults
-    int ret = OK;
     LOG(logINFOBLUE, ("Setting Default Dac values\n"));
     for (int i = 0; i < NDAC; ++i) {
         if (defaultDacValues[i] != -1) {
-            setDAC((enum DACINDEX)i, defaultDacValues[i], 0);
-            if (dacValues[i] != defaultDacValues[i]) {
-                ret = FAIL;
-                LOG(logERROR, ("Setting dac %d failed, wrote %d, read %d\n", i,
-                               defaultDacValues[i], dacValues[i]));
-            }
+            if (setDAC((enum DACINDEX)i, defaultDacValues[i], false, mess) ==
+                FAIL)
+                return FAIL;
         }
     }
     LOG(logINFOBLUE, ("Setting Default On-chip Dac values\n"));
@@ -588,17 +584,18 @@ int resetToDefaultDacs(int hardReset) {
                              defaultOnChipdacValues[idac][ichip]);
                 if (onChipdacValues[idac][ichip] !=
                     defaultOnChipdacValues[idac][ichip]) {
-                    ret = FAIL;
-                    LOG(logERROR,
-                        ("Setting on-chip dac %d (ichip:%d) failed, "
-                         "wrote %d, read %d\n",
-                         idac, ichip, defaultOnChipdacValues[idac][ichip],
-                         onChipdacValues[idac][ichip]));
+                    sprintf(mess,
+                            "Setting on-chip dac %d (ichip:%d) failed, "
+                            "wrote %d, read %d\n",
+                            idac, ichip, defaultOnChipdacValues[idac][ichip],
+                            onChipdacValues[idac][ichip]);
+                    LOG(logERROR, (mess));
+                    return FAIL;
                 }
             }
         }
     }
-    return ret;
+    return OK;
 }
 
 int getDefaultDac(enum DACINDEX index, enum detectorSettings sett,
@@ -952,13 +949,11 @@ int readConfigFile() {
             hardCodedDefaultDacValues[idac] = value;
 
             // set dac
-            setDAC(idac, value, 0);
-            int retval = getDAC(idac, 0);
-            if (retval != value) {
+            if (setDAC(idac, value, false, initErrorMessage) == FAIL) {
                 sprintf(initErrorMessage,
                         "Set dac %s failed from on-board server config file. "
-                        "Set %d, got %d.\n",
-                        command, value, retval);
+                        "Could not set %d.\n",
+                        command, value);
                 break;
             }
         }
@@ -1401,9 +1396,12 @@ int64_t getMeasurementTime() {
 }
 
 /* parameters - module, settings */
-enum detectorSettings setSettings(enum detectorSettings sett) {
-    if (sett == UNINITIALIZED)
-        return thisSettings;
+int setSettings(enum detectorSettings sett, char *mess) {
+    if (sett == UNINITIALIZED) {
+        sprintf(mess, "Cannot set settings to uninitialized\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
 
     // set settings
     uint32_t addr = ASIC_CONFIG_REG;
@@ -1428,13 +1426,13 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
             ("Set settings - Fix Gain 2, val: 0x%x\n", bus_r(addr) & mask));
         break;
     default:
-        LOG(logERROR,
-            ("This settings is not defined for this detector %d\n", (int)sett));
-        return -1;
+        sprintf(mess, "Undefined settings %d\n", (int)sett);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
     thisSettings = sett;
 
-    return getSettings();
+    return OK;
 }
 
 enum detectorSettings getSettings() {
@@ -1523,47 +1521,107 @@ int getOnChipDAC(enum ONCHIP_DACINDEX ind, int chipIndex) {
     return onChipdacValues[ind][chipIndex];
 }
 
-void setDAC(enum DACINDEX ind, int val, int mV) {
-    if (val < 0) {
-        return;
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    if (ind < 0 || ind >= NDAC) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    char *dacNames[] = {DAC_NAMES};
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %s. Input value %d cannot be negative\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %s. Input value %d mV exceeds maximum %d mV\n",
+            dacNames[ind], voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    if (LTC2620_D_VoltageToDac(voltage, retval_dacval) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not set DAC %s. Could not convert %d mV to dac units.\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    if (LTC2620_D_DacToVoltage(dacval, retval_voltage) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not get DAC %s. Could not convert %d dac units to mV\n",
+                dacNames[ind], dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = dacValues[ind];
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
     }
 
-    char *dac_names[] = {DAC_NAMES};
-    LOG(logDEBUG1, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                    val, (mV ? "mV" : "dac units")));
+    *retval = dacval;
+    return OK;
+}
+
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    {
+        char *dacNames[] = {DAC_NAMES};
+        LOG(logINFO, ("Setting DAC %s: %d %s \n", dacNames[ind], val,
+                      (mV ? "mV" : "dac units")));
+    }
+
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
     int dacval = val;
-#ifdef VIRTUAL
-    LOG(logINFO, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                  val, (mV ? "mV" : "dac units")));
-    if (!mV) {
-        dacValues[ind] = val;
-    }
-    // convert to dac units
-    else if (LTC2620_D_VoltageToDac(val, &dacval) == OK) {
-        dacValues[ind] = dacval;
-    }
-#else
-    if (LTC2620_D_SetDACValue((int)ind, val, mV, dac_names[ind], &dacval) ==
-        OK) {
-        dacValues[ind] = dacval;
-    }
-#endif
-}
+    if (mV) {
+        if (validateDACVoltage(ind, val, mess) == FAIL)
+            return FAIL;
 
-int getDAC(enum DACINDEX ind, int mV) {
-    if (!mV) {
-        LOG(logDEBUG1, ("Getting DAC %d : %d dac\n", ind, dacValues[ind]));
-        return dacValues[ind];
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
+            return FAIL;
     }
-    int voltage = -1;
-    LTC2620_D_DacToVoltage(dacValues[ind], &voltage);
-    LOG(logDEBUG1,
-        ("Getting DAC %d : %d dac (%d mV)\n", ind, dacValues[ind], voltage));
-    return voltage;
+    {
+        char *dacNames[] = {DAC_NAMES};
+        if (LTC2620_D_SetDacValue((int)ind, dacval, dacNames[ind], mess) ==
+            FAIL)
+            return FAIL;
+    }
+    dacValues[ind] = dacval;
+    return OK;
 }
 
-int getMaxDacSteps() { return LTC2620_D_GetMaxNumSteps(); }
-
 int getADC(enum ADCINDEX ind, int *value) {
     LOG(logDEBUG1, ("Reading FPGA temperature...\n"));
     if (readParameterFromFile(TEMPERATURE_FILE_NAME, "temperature", value) ==
@@ -1575,9 +1633,12 @@ int getADC(enum ADCINDEX ind, int *value) {
     return OK;
 }
 
-int setHighVoltage(int val) {
-    if (val > HV_SOFT_MAX_VOLTAGE) {
-        LOG(logERROR, ("Invalid high voltage: %d V\n", val));
+int setHighVoltage(int val, char *mess) {
+    // validate input value
+    if (val < 0 || val > HV_SOFT_MAX_VOLTAGE) {
+        sprintf(mess, "Invalid Voltage. Valid range (0 - %d)\n",
+                HV_SOFT_MAX_VOLTAGE);
+        LOG(logERROR, (mess));
         return FAIL;
     }
 
@@ -1589,7 +1650,7 @@ int setHighVoltage(int val) {
     // at startup (initCheck not done: to not wait 10s assuming hv = 0
     // otherwise as below, always check current hv to wait 10s if powering off
     if (initCheckDone) {
-        if (getHighVoltage(&prevHighVoltage) == FAIL) {
+        if (getHighVoltage(&prevHighVoltage, mess) == FAIL) {
             LOG(logERROR, ("Could not get current high voltage to determine if "
                            "%d s wait is required\n",
                            waitTime));
@@ -1597,21 +1658,36 @@ int setHighVoltage(int val) {
         }
     }
 
-    int ret = DAC6571_Set(val);
+    if (DAC6571_Set(val, mess) == FAIL)
+        return FAIL;
 
     // only when powering off (from non zero value), wait 10s
-    if (ret == OK) {
-        if (prevHighVoltage > 0 && val == 0) {
-            LOG(logINFO,
-                ("\tSwitching off high voltage requires %d s...\n", waitTime));
-            sleep(waitTime);
-            LOG(logINFO, ("\tAssuming high voltage switched off\n"));
-        }
+    if (prevHighVoltage > 0 && val == 0) {
+        LOG(logINFO,
+            ("\tSwitching off high voltage requires %d s...\n", waitTime));
+        sleep(waitTime);
+        LOG(logINFO, ("\tAssuming high voltage switched off\n"));
     }
-    return ret;
+
+    // validate get
+    int retval = 0;
+    if (getHighVoltage(&retval, mess) == FAIL)
+        return FAIL;
+    if (val != retval) {
+        sprintf(mess, "Could not set high voltage. Set %d, but got %d\n", val,
+                retval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    return OK;
 }
 
-int getHighVoltage(int *retval) { return DAC6571_Get(retval); }
+int getHighVoltage(int *retval, char *mess) {
+    int ret = DAC6571_Get(retval, mess);
+    LOG(logDEBUG1, ("High Voltage: %d\n", *retval));
+    return ret;
+}
 
 /* parameters - timing */
 
@@ -2285,7 +2361,7 @@ int powerChip(int on, char *mess) {
     } else {
         // throw if high voltage on
         int highVoltage = 0;
-        if (getHighVoltage(&highVoltage) == FAIL) {
+        if (getHighVoltage(&highVoltage, mess) == FAIL) {
             sprintf(mess, "Could not get high voltage status to do a safety "
                           "check first\n");
             LOG(logERROR, (mess));

slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.h

@@ -6,6 +6,7 @@
 #include "nios.h"
 #include "programViaNios.h"
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -62,7 +63,7 @@ void initStopServer();
 
 // set up detector
 void setupDetector();
-int resetToDefaultDacs(int hardReset);
+int resetToDefaultDacs(int hardReset, char *mess);
 int getDefaultDac(enum DACINDEX index, enum detectorSettings sett, int *retval);
 int setDefaultDac(enum DACINDEX index, enum detectorSettings sett, int value);
 void setASICDefaults();
@@ -109,19 +110,25 @@ int64_t getActualTime();
 int64_t getMeasurementTime();
 
 // parameters - module, settings
-enum detectorSettings setSettings(enum detectorSettings sett);
+int setSettings(enum detectorSettings sett, char *mess);
 enum detectorSettings getSettings();
 
 // parameters - dac, adc, hv
 int setOnChipDAC(enum ONCHIP_DACINDEX ind, int chipIndex, int val);
 int getOnChipDAC(enum ONCHIP_DACINDEX ind, int chipIndex);
-void setDAC(enum DACINDEX ind, int val, int mV);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
+
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
 
 int getADC(enum ADCINDEX ind, int *value);
-int setHighVoltage(int val);
-int getHighVoltage(int *retval);
+int setHighVoltage(int val, char *mess);
+int getHighVoltage(int *retval, char *mess);
 
 // parameters - timing, extsig
 int setMaster(enum MASTERINDEX m);

slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c

@@ -488,7 +488,9 @@ void setupDetector() {
                        SPI_HV_SRL_DGTL_OTPT_MSK, SPI_HV_SRL_DGTL_OTPT_OFST,
                        HIGHVOLTAGE_MIN, HIGHVOLTAGE_MAX);
     MAX1932_Disable();
-    setHighVoltage(DEFAULT_HIGH_VOLTAGE);
+    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     // adc
     AD9257_SetDefines(ADC_SPI_REG, ADC_SPI_SRL_CS_OTPT_MSK,
@@ -505,7 +507,9 @@ void setupDetector() {
                        DAC_MAX_MV);
     LTC2620_Disable();
     LTC2620_Configure();
-    resetToDefaultDacs(0);
+    initError = resetToDefaultDacs(0, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     /* Only once at server startup */
     bus_w(DAQ_REG, 0x0);
@@ -535,7 +539,9 @@ void setupDetector() {
 
     // Initialization of acquistion parameters
     disableCurrentSource();
-    setSettings(DEFAULT_SETTINGS);
+    initError = setSettings(DEFAULT_SETTINGS, initErrorMessage);
+    if (initError == FAIL)
+        return;
     setGainMode(DEFAULT_GAINMODE);
 
     setNumFrames(DEFAULT_NUM_FRAMES);
@@ -577,7 +583,7 @@ void setupDetector() {
     setElectronCollectionMode(DEFAULT_ELECTRON_COLLECTION_MODE);
 }
 
-int resetToDefaultDacs(int hardReset) {
+int resetToDefaultDacs(int hardReset, char *mess) {
     LOG(logINFOBLUE, ("Resetting %s to Default Dac values\n",
                       (hardReset == 1 ? "hard" : "")));
 
@@ -622,13 +628,9 @@ int resetToDefaultDacs(int hardReset) {
             }
         }
 
-        // set to defualt
-        setDAC((enum DACINDEX)i, value, 0);
-        if (dacValues[i] != value) {
-            LOG(logERROR, ("Setting dac %d failed, wrote %d, read %d\n", i,
-                           value, dacValues[i]));
+        // set to default
+        if (setDAC((enum DACINDEX)i, value, false, mess) == FAIL)
             return FAIL;
-        }
     }
     return OK;
 }
@@ -1179,17 +1181,23 @@ int setModule(sls_detector_module myMod, char *mess) {
     LOG(logINFO, ("Setting module with settings %d\n", myMod.reg));
 
     // settings
-    setSettings((enum detectorSettings)myMod.reg);
+    if (setSettings((enum detectorSettings)myMod.reg, mess) == FAIL)
+        return FAIL;
 
     // set dac values
-    for (int i = 0; i < NDAC; ++i)
-        setDAC((enum DACINDEX)i, myMod.dacs[i], 0);
+    for (int i = 0; i < NDAC; ++i) {
+        if (setDAC((enum DACINDEX)i, myMod.dacs[i], false, mess) == FAIL)
+            return FAIL;
+    }
     return OK;
 }
 
-enum detectorSettings setSettings(enum detectorSettings sett) {
-    if (sett == UNINITIALIZED)
-        return thisSettings;
+int setSettings(enum detectorSettings sett, char *mess) {
+    if (sett == UNINITIALIZED) {
+        sprintf(mess, "Cannot set settings to uninitialized\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
 
     int *dacVals = NULL;
     // set settings
@@ -1207,8 +1215,9 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
         dacVals = defaultDacValue_HG0;
         break;
     default:
-        LOG(logERROR, ("This settings %d is not defined\n", (int)sett));
-        return -1;
+        sprintf(mess, "Undefined settings %d\n", (int)sett);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
     thisSettings = sett;
@@ -1216,13 +1225,14 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
     // set special dacs
     const int specialDacs[] = SPECIALDACINDEX;
     for (int i = 0; i < NSPECIALDACS; ++i) {
-        setDAC(specialDacs[i], dacVals[i], 0);
+        if (setDAC(specialDacs[i], dacVals[i], false, mess) == FAIL)
+            return FAIL;
     }
 
     // if chipv1.1 and powered on
     configureChip();
 
-    return getSettings();
+    return OK;
 }
 
 enum detectorSettings getSettings() {
@@ -1326,52 +1336,112 @@ void setGainMode(enum gainMode mode) {
 }
 
 /* parameters - dac, adc, hv */
-void setDAC(enum DACINDEX ind, int val, int mV) {
-    if (val < 0)
-        return;
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    if (ind < 0 || ind >= NDAC) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    char *dacNames[] = {DAC_NAMES};
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %s. Input value %d cannot be negative\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %s. Input value %d mV exceeds maximum %d mV\n",
+            dacNames[ind], voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    if (LTC2620_VoltageToDac(voltage, retval_dacval) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not set DAC %s. Could not convert %d mV to dac units.\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    if (LTC2620_DacToVoltage(dacval, retval_voltage) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not get DAC %s. Could not convert %d dac units to mV\n",
+                dacNames[ind], dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = dacValues[ind];
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
+    }
+
+    *retval = dacval;
+    return OK;
+}
+
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    {
+        char *dacNames[] = {DAC_NAMES};
+        LOG(logINFO, ("Setting DAC %s: %d %s \n", dacNames[ind], val,
+                      (mV ? "mV" : "dac units")));
+    }
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
 
-    char *dac_names[] = {DAC_NAMES};
     int dacval = val;
-#ifdef VIRTUAL
-    LOG(logINFO, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                  val, (mV ? "mV" : "dac units")));
-    if (!mV) {
-        dacValues[ind] = val;
+    if (mV) {
+        if (validateDACVoltage(ind, val, mess) == FAIL)
+            return FAIL;
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
+            return FAIL;
     }
-    // convert to dac units
-    else if (LTC2620_VoltageToDac(val, &dacval) == OK) {
-        dacValues[ind] = dacval;
+    {
+        char *dacNames[] = {DAC_NAMES};
+        if (LTC2620_SetDacValue((int)ind, dacval, dacNames[ind], mess) == FAIL)
+            return FAIL;
     }
-#else
-    LOG(logINFO, ("Setting DAC %s\n", dac_names[ind]));
-    if (LTC2620_SetDACValue((int)ind, val, mV, &dacval) == OK) {
-        dacValues[ind] = dacval;
-        if (ind == J_VREF_COMP &&
-            (val >= 0)) { // FIXME: if val == pwr down value, write 0?
-            bus_w(EXT_DAQ_CTRL_REG,
-                  (bus_r(EXT_DAQ_CTRL_REG) &
-                   ~(EXT_DAQ_CTRL_VREF_COMP_MSK)) // reset
-                      | ((val << EXT_DAQ_CTRL_VREF_COMP_OFST) &
-                         EXT_DAQ_CTRL_VREF_COMP_MSK)); // or it with value
-        }
-    }
-#endif
-}
+    dacValues[ind] = dacval;
 
-int getDAC(enum DACINDEX ind, int mV) {
-    if (!mV) {
-        LOG(logDEBUG1, ("Getting DAC %d : %d dac\n", ind, dacValues[ind]));
-        return dacValues[ind];
+    // ext daq ctrl
+    if (ind == J_VREF_COMP) {
+        uint32_t addr = EXT_DAQ_CTRL_REG;
+        bus_w(addr, (bus_r(addr) & ~(EXT_DAQ_CTRL_VREF_COMP_MSK)));
+        bus_w(addr, (bus_r(addr) | ((dacval << EXT_DAQ_CTRL_VREF_COMP_OFST) &
+                                    EXT_DAQ_CTRL_VREF_COMP_MSK)));
     }
-    int voltage = -1;
-    LTC2620_DacToVoltage(dacValues[ind], &voltage);
-    LOG(logDEBUG1,
-        ("Getting DAC %d : %d dac (%d mV)\n", ind, dacValues[ind], voltage));
-    return voltage;
+    return OK;
 }
 
-int getMaxDacSteps() { return LTC2620_GetMaxNumSteps(); }
-
 int getADC(enum ADCINDEX ind) {
 #ifdef VIRTUAL
     return 0;
@@ -1398,14 +1468,18 @@ int getADC(enum ADCINDEX ind) {
     return retval;
 }
 
-int setHighVoltage(int val) {
-    // setting hv
-    if (val >= 0) {
-        LOG(logINFO, ("Setting High voltage: %d V", val));
-        MAX1932_Set(&val);
-        highvoltage = val;
-    }
-    return highvoltage;
+int setHighVoltage(int val, char *mess) {
+    LOG(logINFO, ("Setting High voltage: %d V\n", val));
+    if (MAX1932_Set(val, mess) == FAIL)
+        return FAIL;
+    highvoltage = val;
+    return OK;
+}
+
+int getHighVoltage(int *retval, char *mess) {
+    LOG(logDEBUG1, ("High Voltage: %d\n", *retval));
+    *retval = highvoltage;
+    return OK;
 }
 
 /* parameters - timing, extsig */

slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.h

@@ -7,6 +7,7 @@
 #include "blackfin.h"
 #include "programViaBlackfin.h"
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -71,7 +72,7 @@ void initStopServer();
 
 // set up detector
 void setupDetector();
-int resetToDefaultDacs(int hardReset);
+int resetToDefaultDacs(int hardReset, char *mess);
 int getDefaultDac(enum DACINDEX index, enum detectorSettings sett, int *retval);
 int setDefaultDac(enum DACINDEX index, enum detectorSettings sett, int value);
 int readConfigFile();
@@ -116,18 +117,25 @@ int64_t getMeasurementTime();
 
 // parameters - module, settings
 int setModule(sls_detector_module myMod, char *mess);
-enum detectorSettings setSettings(enum detectorSettings sett);
+int setSettings(enum detectorSettings sett, char *mess);
 enum detectorSettings getSettings();
 enum gainMode getGainMode();
 void setGainMode(enum gainMode mode);
 
 // parameters - dac, adc, hv
-void setDAC(enum DACINDEX ind, int val, int mV);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
+
 int getADC(enum ADCINDEX ind);
-int setHighVoltage(int val);
-int getHighVoltage(int *retval);
+int setHighVoltage(int val, char *mess);
+int getHighVoltage(int *retval, char *mess);
 
 // parameters - timing, extsig
 int setMaster(enum MASTERINDEX m);

slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c

@@ -461,7 +461,9 @@ void setupDetector() {
                        SPI_HV_SRL_DGTL_OTPT_MSK, SPI_HV_SRL_DGTL_OTPT_OFST,
                        HIGHVOLTAGE_MIN, HIGHVOLTAGE_MAX);
     MAX1932_Disable();
-    setHighVoltage(DEFAULT_HIGH_VOLTAGE);
+    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     // adc
     AD9257_SetDefines(ADC_SPI_REG, ADC_SPI_SRL_CS_OTPT_MSK,
@@ -477,7 +479,9 @@ void setupDetector() {
                        DAC_MAX_MV);
     LTC2620_Disable();
     LTC2620_Configure();
-    resetToDefaultDacs(0);
+    initError = resetToDefaultDacs(0, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     LOG(logINFOBLUE, ("Setting Default parameters\n"));
 
@@ -499,7 +503,9 @@ void setupDetector() {
 
     // Initialization of acquistion parameters
     setReadoutSpeed(DEFAULT_SPEED);
-    setSettings(DEFAULT_SETTINGS);
+    initError = setSettings(DEFAULT_SETTINGS, initErrorMessage);
+    if (initError == FAIL)
+        return;
     setNumFrames(DEFAULT_NUM_FRAMES);
     setNumTriggers(DEFAULT_NUM_CYCLES);
     setExpTime(DEFAULT_EXPTIME);
@@ -518,7 +524,7 @@ void setupDetector() {
     setParallelMode(DEFAULT_PARALLEL_ENABLE);
 }
 
-int resetToDefaultDacs(int hardReset) {
+int resetToDefaultDacs(int hardReset, char *mess) {
     LOG(logINFOBLUE, ("Resetting %s to Default Dac values\n",
                       (hardReset == 1 ? "hard" : "")));
 
@@ -534,12 +540,8 @@ int resetToDefaultDacs(int hardReset) {
     for (int i = 0; i < NDAC; ++i) {
         int value = defaultDacValues[i];
         // set to defualt
-        setDAC((enum DACINDEX)i, value, 0);
-        if (dacValues[i] != value) {
-            LOG(logERROR, ("Setting dac %d failed, wrote %d, read %d\n", i,
-                           value, dacValues[i]));
+        if (setDAC((enum DACINDEX)i, value, false, mess) == FAIL)
             return FAIL;
-        }
     }
     return OK;
 }
@@ -807,17 +809,23 @@ int setModule(sls_detector_module myMod, char *mess) {
     LOG(logINFO, ("Setting module with settings %d\n", myMod.reg));
 
     // settings
-    setSettings((enum detectorSettings)myMod.reg);
+    if (setSettings((enum detectorSettings)myMod.reg, mess) == FAIL)
+        return FAIL;
 
     // set dac values
-    for (int i = 0; i < NDAC; ++i)
-        setDAC((enum DACINDEX)i, myMod.dacs[i], 0);
+    for (int i = 0; i < NDAC; ++i) {
+        if (setDAC((enum DACINDEX)i, myMod.dacs[i], false, mess) == FAIL)
+            return FAIL;
+    }
     return OK;
 }
 
-enum detectorSettings setSettings(enum detectorSettings sett) {
-    if (sett == UNINITIALIZED)
-        return thisSettings;
+int setSettings(enum detectorSettings sett, char *mess) {
+    if (sett == UNINITIALIZED) {
+        sprintf(mess, "Cannot set settings to uninitialized\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
 
     uint32_t mask = 0;
     // set settings
@@ -855,8 +863,9 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
         mask = SETTINGS_G4_LG;
         break;
     default:
-        LOG(logERROR, ("This settings %d is not defined\n", (int)sett));
-        return -1;
+        sprintf(mess, "Undefined settings %d\n", (int)sett);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
     uint32_t addr = ASIC_CTRL_REG;
@@ -864,7 +873,7 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
     bus_w(addr, bus_r(addr) | mask);
 
     thisSettings = sett;
-    return getSettings();
+    return OK;
 }
 
 enum detectorSettings getSettings() {
@@ -902,44 +911,105 @@ enum detectorSettings getSettings() {
 }
 
 /* parameters - dac, adc, hv */
-void setDAC(enum DACINDEX ind, int val, int mV) {
-    if (val < 0)
-        return;
+/* parameters - dac, adc, hv */
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    if (ind < 0 || ind >= NDAC) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    char *dacNames[] = {DAC_NAMES};
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %s. Input value %d cannot be negative\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %s. Input value %d mV exceeds maximum %d mV\n",
+            dacNames[ind], voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    if (LTC2620_VoltageToDac(voltage, retval_dacval) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not set DAC %s. Could not convert %d mV to dac units.\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    if (LTC2620_DacToVoltage(dacval, retval_voltage) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not get DAC %s. Could not convert %d dac units to mV\n",
+                dacNames[ind], dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = dacValues[ind];
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
+    }
+
+    *retval = dacval;
+    return OK;
+}
+
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    {
+        char *dacNames[] = {DAC_NAMES};
+        LOG(logINFO, ("Setting DAC %s: %d %s \n", dacNames[ind], val,
+                      (mV ? "mV" : "dac units")));
+    }
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
 
-    char *dac_names[] = {DAC_NAMES};
     int dacval = val;
-#ifdef VIRTUAL
-    LOG(logINFO, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                  val, (mV ? "mV" : "dac units")));
-    if (!mV) {
-        dacValues[ind] = val;
+    if (mV) {
+        if (validateDACVoltage(ind, val, mess) == FAIL)
+            return FAIL;
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
+            return FAIL;
     }
-    // convert to dac units
-    else if (LTC2620_VoltageToDac(val, &dacval) == OK) {
-        dacValues[ind] = dacval;
+    {
+        char *dacNames[] = {DAC_NAMES};
+        if (LTC2620_SetDacValue((int)ind, dacval, dacNames[ind], mess) == FAIL)
+            return FAIL;
     }
-#else
-    LOG(logINFO, ("Setting DAC %s\n", dac_names[ind]));
-    if (LTC2620_SetDACValue((int)ind, val, mV, &dacval) == OK) {
-        dacValues[ind] = dacval;
-    }
-#endif
+    dacValues[ind] = dacval;
+    return OK;
 }
 
-int getDAC(enum DACINDEX ind, int mV) {
-    if (!mV) {
-        LOG(logDEBUG1, ("Getting DAC %d : %d dac\n", ind, dacValues[ind]));
-        return dacValues[ind];
-    }
-    int voltage = -1;
-    LTC2620_DacToVoltage(dacValues[ind], &voltage);
-    LOG(logDEBUG1,
-        ("Getting DAC %d : %d dac (%d mV)\n", ind, dacValues[ind], voltage));
-    return voltage;
-}
-
-int getMaxDacSteps() { return LTC2620_GetMaxNumSteps(); }
-
 int getADC(enum ADCINDEX ind) {
 #ifdef VIRTUAL
     return 0;
@@ -966,14 +1036,18 @@ int getADC(enum ADCINDEX ind) {
     return retval;
 }
 
-int setHighVoltage(int val) {
-    // setting hv
-    if (val >= 0) {
-        LOG(logINFO, ("Setting High voltage: %d V", val));
-        MAX1932_Set(&val);
-        highvoltage = val;
-    }
-    return highvoltage;
+int setHighVoltage(int val, char *mess) {
+    LOG(logINFO, ("Setting High voltage: %d V\n", val));
+    if (MAX1932_Set(val, mess) == FAIL)
+        return FAIL;
+    highvoltage = val;
+    return OK;
+}
+
+int getHighVoltage(int *retval, char *mess) {
+    LOG(logDEBUG1, ("High Voltage: %d\n", *retval));
+    *retval = highvoltage;
+    return OK;
 }
 
 /* parameters - timing, extsig */

slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.h

@@ -7,6 +7,7 @@
 #include "blackfin.h"
 #include "programViaBlackfin.h"
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -69,7 +70,7 @@ void initStopServer();
 
 // set up detector
 void setupDetector();
-int resetToDefaultDacs(int hardReset);
+int resetToDefaultDacs(int hardReset, char *mess);
 int getDefaultDac(enum DACINDEX index, enum detectorSettings sett, int *retval);
 int setDefaultDac(enum DACINDEX index, enum detectorSettings sett, int value);
 
@@ -111,15 +112,23 @@ int64_t getMeasurementTime();
 
 // parameters - module, settings
 int setModule(sls_detector_module myMod, char *mess);
-enum detectorSettings setSettings(enum detectorSettings sett);
+int setSettings(enum detectorSettings sett, char *mess);
 enum detectorSettings getSettings();
 
 // parameters - dac, adc, hv
-void setDAC(enum DACINDEX ind, int val, int mV);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
+
 int getADC(enum ADCINDEX ind);
-int setHighVoltage(int val);
+int setHighVoltage(int val, char *mess);
+int getHighVoltage(int *retval, char *mess);
 
 // parameters - timing, extsig
 int setMaster(enum MASTERINDEX m);

slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c

@@ -493,10 +493,8 @@ void setupDetector() {
     cleanFifos();
 
     // defaults
-    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE);
+    initError = setHighVoltage(DEFAULT_HIGH_VOLTAGE, initErrorMessage);
     if (initError == FAIL) {
-        sprintf(initErrorMessage, "Could not set high voltage to %d\n",
-                DEFAULT_HIGH_VOLTAGE);
         return;
     }
 
@@ -506,8 +504,12 @@ void setupDetector() {
     initializePatternAddresses();
 
     // enable all counters before setting dacs (vthx)
-    setCounterMask(MAX_COUNTER_MSK);
-    resetToDefaultDacs(0);
+    initError = setCounterMask(MAX_COUNTER_MSK, initErrorMessage);
+    if (initError == FAIL)
+        return;
+    initError = resetToDefaultDacs(0, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     // set trigger flow for m3 (for all timing modes)
     bus_w(FLOW_TRIGGER_REG, bus_r(FLOW_TRIGGER_REG) | FLOW_TRIGGER_MSK);
@@ -530,7 +532,9 @@ void setupDetector() {
     setInitialExtSignals();
     // 10G UDP
     enableTenGigabitEthernet(1);
-    setSettings(DEFAULT_SETTINGS);
+    initError = setSettings(DEFAULT_SETTINGS, initErrorMessage);
+    if (initError == FAIL)
+        return;
 
     // check module type attached if not in debug mode
     if (initError == FAIL)
@@ -554,7 +558,7 @@ void setupDetector() {
     setReadoutSpeed(DEFAULT_READOUT_SPEED);
 }
 
-int resetToDefaultDacs(int hardReset) {
+int resetToDefaultDacs(int hardReset, char *mess) {
     LOG(logINFOBLUE, ("Resetting %s to Default Dac values\n",
                       (hardReset == 1 ? "hard" : "")));
 
@@ -606,13 +610,12 @@ int resetToDefaultDacs(int hardReset) {
             }
         }
 
-        // set to default (last arg to ensure counter check)
-        setDAC((enum DACINDEX)i, value, 0, 1);
-        if (detectorDacs[i] != value) {
-            LOG(logERROR, ("Setting dac %d failed, wrote %d, read %d\n", i,
-                           value, detectorDacs[i]));
+        // set to default
+        if (updateValueForVthDac(i, &value, mess) == FAIL)
+            return FAIL;
+
+        if (setDAC((enum DACINDEX)i, value, false, mess) == FAIL)
             return FAIL;
-        }
     }
     return OK;
 }
@@ -913,10 +916,10 @@ int getNumGates() { return bus_r(ASIC_EXP_EXT_GATE_NUMBER_REG); }
 
 void updateGatePeriod() {
     uint64_t max = 0;
-    uint32_t countermask = getCounterMask();
+    uint32_t mask = getCounterMask();
     for (int i = 0; i != NCOUNTERS; ++i) {
         // only if counter enabled
-        if (countermask & (1 << i)) {
+        if (mask & (1 << i)) {
             uint64_t sum = getExpTime(i) + getGateDelay(i);
             if (sum > max) {
                 max = sum;
@@ -1097,43 +1100,77 @@ int64_t getGateDelay(int gateIndex) {
     return retval / (1E-9 * getFrequency(SYSTEM_C0));
 }
 
-void updateVthAndCounterMask() {
+int updateVthAndCounterMask(char *mess) {
     LOG(logINFO, ("\tUpdating Vth and countermask\n"));
     int interpolation = getInterpolation();
     int pumpProbe = getPumpProbe();
 
     if (interpolation) {
         // enable all counters
-        setCounterMaskWithUpdateFlag(MAX_COUNTER_MSK, 0);
-        // disable vth3
-        setVthDac(2, 0);
+        if (setCounterMaskAndTimeRegisters(MAX_COUNTER_MSK, mess) == FAIL)
+            return FAIL;
+        if (setVthEnabled(M_VTH3, false, mess) == FAIL)
+            return FAIL;
     } else {
         // previous counter values
-        setCounterMaskWithUpdateFlag(counterMask, 0);
+        if (setCounterMaskAndTimeRegisters(counterMask, mess) == FAIL)
+            return FAIL;
     }
+
     if (pumpProbe) {
         // enable only vth2
-        setVthDac(0, 0);
-        setVthDac(1, 1);
-        setVthDac(2, 0);
+        if (setVthEnabled(M_VTH1, false, mess) == FAIL)
+            return FAIL;
+        if (setVthEnabled(M_VTH2, true, mess) == FAIL)
+            return FAIL;
+        if (setVthEnabled(M_VTH3, false, mess) == FAIL)
+            return FAIL;
     } else {
-        setVthDac(0, (counterMask & (1 << 0)));
-        setVthDac(1, (counterMask & (1 << 1)));
+        // enable vth1 and vth2 as per counter mask
+        bool counterEnabled = (counterMask & (1 << 0));
+        if (setVthEnabled(M_VTH1, counterEnabled, mess) == FAIL)
+            return FAIL;
+        counterEnabled = (counterMask & (1 << 1));
+        if (setVthEnabled(M_VTH2, counterEnabled, mess) == FAIL)
+            return FAIL;
     }
+
+    // normal mode, enable vth3 as per counter mask
     if (!interpolation && !pumpProbe) {
-        setVthDac(2, (counterMask & (1 << 2)));
+        bool counterEnabled = (counterMask & (1 << 2));
+        if (setVthEnabled(M_VTH3, counterEnabled, mess) == FAIL)
+            return FAIL;
     }
+    return OK;
 }
 
-void setCounterMask(uint32_t arg) {
-    setCounterMaskWithUpdateFlag(arg, 1);
-    updateVthAndCounterMask();
+int setCounterMask(uint32_t arg, char *mess) {
+
+    if (setCounterMaskAndTimeRegisters(arg, mess) == FAIL)
+        return FAIL;
+    counterMask = arg;
+
+    if (updateVthAndCounterMask(mess) == FAIL)
+        return FAIL;
+
+    if (getCounterMask() != arg) {
+        sprintf(mess, "Failed to set counter mask to 0x%x\n", arg);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
 }
 
-void setCounterMaskWithUpdateFlag(uint32_t arg, int updateMaskFlag) {
-    if (arg == 0 || arg > MAX_COUNTER_MSK) {
-        return;
+int setCounterMaskAndTimeRegisters(uint32_t arg, char *mess) {
+    if (arg <= 0 || arg > MAX_COUNTER_MSK) {
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not set counter mask to 0x%x. Valid values are between "
+                 "0 and 0x%x\n",
+                 arg, MAX_COUNTER_MSK);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
+
     LOG(logINFO, ("\tSetting counter mask to  0x%x\n", arg));
     uint32_t addr = CONFIG_REG;
     bus_w(addr, bus_r(addr) & ~CONFIG_COUNTERS_ENA_MSK);
@@ -1142,6 +1179,7 @@ void setCounterMaskWithUpdateFlag(uint32_t arg, int updateMaskFlag) {
     LOG(logDEBUG, ("Config Reg: 0x%x\n", bus_r(addr)));
 
     updatePacketizing();
+
     LOG(logINFO, ("\tUpdating Exptime and Gate Delay\n"));
     for (int i = 0; i < NCOUNTERS; ++i) {
         uint64_t ns = exptimeReg[i] / (1E-9 * getFrequency(SYSTEM_C0));
@@ -1149,10 +1187,7 @@ void setCounterMaskWithUpdateFlag(uint32_t arg, int updateMaskFlag) {
         ns = gateDelayReg[i] / (1E-9 * getFrequency(SYSTEM_C0));
         setGateDelay(i, ns);
     }
-
-    if (updateMaskFlag) {
-        counterMask = arg;
-    }
+    return OK;
 }
 
 uint32_t getCounterMask() {
@@ -1269,24 +1304,6 @@ int64_t getMeasurementTime() {
 
 /* parameters - module, speed, readout */
 
-int setDACS(int *dacs) {
-    for (int i = 0; i < NDAC; ++i) {
-        if (dacs[i] != -1) {
-            // set to default (last arg to ensure counter check)
-            setDAC((enum DACINDEX)i, dacs[i], 0, 1);
-            if (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;
-                }
-                return FAIL;
-            }
-        }
-    }
-    return OK;
-}
-
 void getModule(sls_detector_module *myMod) {
     // serial number
     myMod->serialnumber = detectorModules->serialnumber;
@@ -1328,15 +1345,21 @@ int setModule(sls_detector_module myMod, char *mess) {
         return FAIL;
     }
 
-    // dacs
-    if (setDACS(myMod.dacs)) {
-        sprintf(mess, "Could not set dacs\n");
-        LOG(logERROR, (mess));
-        return FAIL;
+    // dacs myMod.dacs
+    for (enum DACINDEX i = 0; i < NDAC; ++i) {
+        if (myMod.dacs[i] != -1) {
+            if (updateValueForVthDac(i, &(myMod.dacs[i]), mess) == FAIL)
+                return FAIL;
+            // set to default
+            if (setDAC(i, myMod.dacs[i], false, mess) == FAIL) {
+                return FAIL;
+            }
+        }
     }
 
     // update vth and countermask
-    updateVthAndCounterMask();
+    if (updateVthAndCounterMask(mess) == FAIL)
+        return FAIL;
 
     // threshold energy
     for (int i = 0; i < NCOUNTERS; ++i) {
@@ -1456,7 +1479,7 @@ int getAllTrimbits() {
     return value;
 }
 
-enum detectorSettings setSettings(enum detectorSettings sett) {
+int setSettings(enum detectorSettings sett, char *mess) {
     int *dacVals = NULL;
     switch (sett) {
     case STANDARD:
@@ -1472,9 +1495,9 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
         dacVals = defaultDacValue_highgain;
         break;
     default:
-        LOG(logERROR,
-            ("Settings %d not defined for this detector\n", (int)sett));
-        return thisSettings;
+        sprintf(mess, "Undefined settings %d\n", (int)sett);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
     thisSettings = sett;
@@ -1482,12 +1505,12 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
     // set special dacs
     const int specialDacs[] = SPECIALDACINDEX;
     for (int i = 0; i < NSPECIALDACS; ++i) {
-        // set to default (last arg to ensure counter check)
-        setDAC(specialDacs[i], dacVals[i], 0, 1);
+        if (setDAC(specialDacs[i], dacVals[i], false, mess) == FAIL)
+            return FAIL;
     }
 
     LOG(logINFO, ("Settings: %d\n", thisSettings));
-    return thisSettings;
+    return OK;
 }
 
 void validateSettings() {
@@ -1507,7 +1530,13 @@ void validateSettings() {
         sett = settList[isett];
         // if one value does not match, = undefined
         for (int i = 0; i < NSPECIALDACS; ++i) {
-            if (getDAC(specialDacs[i], 0) != specialDacValues[isett][i]) {
+            int retval = 0;
+            char emsg[MAX_STR_LENGTH] = {0};
+            if (getDAC(specialDacs[i], false, &retval, emsg) == FAIL) {
+                sett = UNDEFINED;
+                break;
+            }
+            if (retval != specialDacValues[isett][i]) {
                 sett = UNDEFINED;
                 break;
             }
@@ -1543,143 +1572,260 @@ void setThresholdEnergy(int counterIndex, int eV) {
 }
 
 /* parameters - dac, hv */
-// counterEnableCheck false only if setDAC called directly
-void setDAC(enum DACINDEX ind, int val, int mV, int counterEnableCheck) {
-    // invalid value
-    if (val < 0) {
-        return;
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    // threshold included
+    if (ind < 0 || ind >= NDAC + 1) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    // out of scope, NDAC + 1 for vthreshold
-    if ((int)ind > NDAC + 1) {
-        LOG(logERROR, ("Unknown dac index %d\n", ind));
-        return;
-    }
-
-    // threshold dacs
-    // remember value, vthreshold: skip disabled,
-    // others: disable or enable dac if counter mask
-    // setDAC called directly: will set independent of counter enable
-    if (ind == M_VTHRESHOLD || ind == M_VTH1 || ind == M_VTH2 ||
-        ind == M_VTH3) {
-        char *dac_names[] = {DAC_NAMES};
-        int vthdacs[] = {M_VTH1, M_VTH2, M_VTH3};
-        uint32_t counters = getCounterMask();
-        for (int i = 0; i < NCOUNTERS; ++i) {
-            if ((int)ind == vthdacs[i] || ind == M_VTHRESHOLD) {
-                int dacval = val;
-                // if not disabled value, remember value
-                if (dacval != DEFAULT_COUNTER_DISABLED_VTH_VAL) {
-                    if (mV) {
-                        if (LTC2620_D_VoltageToDac(val, &dacval) == FAIL) {
-                            return;
-                        }
-                    }
-                    vthEnabledVals[i] = dacval;
-                    LOG(logINFO,
-                        ("Remembering %s [%d]\n", dac_names[ind], dacval));
-                }
-                // disabled counter
-                if (!(counters & (1 << i))) {
-                    // skip setting vthx dac (value remembered anyway)
-                    if (ind == M_VTHRESHOLD) {
-                        continue;
-                    }
-                    // disable dac (except when setting dac directly)
-                    if (counterEnableCheck) {
-                        val = DEFAULT_COUNTER_DISABLED_VTH_VAL;
-                    }
-                }
-                setGeneralDAC(vthdacs[i], val, mV);
-            }
-        }
-        return;
-    }
-
-    setGeneralDAC(ind, val, mV);
+    return OK;
 }
 
-void setGeneralDAC(enum DACINDEX ind, int val, int mV) {
-    char *dac_names[] = {DAC_NAMES};
-    LOG(logDEBUG1, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                    val, (mV ? "mV" : "dac units")));
-    int dacval = val;
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    char *dacNames[] = {DAC_NAMES};
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %s. Input value %d cannot be negative\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %s. Input value %d mV exceeds maximum %d mV\n",
+            dacNames[ind], voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
 
-#ifdef VIRTUAL
-    LOG(logINFO, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dac_names[ind],
-                  val, (mV ? "mV" : "dac units")));
-    if (!mV) {
-        detectorDacs[ind] = val;
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    if (LTC2620_D_VoltageToDac(voltage, retval_dacval) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not set DAC %s. Could not convert %d mV to dac units.\n",
+                dacNames[ind], voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    // convert to dac units
-    else if (LTC2620_D_VoltageToDac(val, &dacval) == OK) {
-        detectorDacs[ind] = dacval;
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    if (LTC2620_D_DacToVoltage(dacval, retval_voltage) == FAIL) {
+        char *dacNames[] = {DAC_NAMES};
+        sprintf(mess,
+                "Could not get DAC %s. Could not convert %d dac units to mV\n",
+                dacNames[ind], dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-#else
-    if (LTC2620_D_SetDACValue((int)ind, val, mV, dac_names[ind], &dacval) ==
-        OK) {
-        detectorDacs[ind] = dacval;
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    if (ind == M_VTHRESHOLD) {
+        return getThresholdDACs(mV, retval, mess);
     }
-#endif
+
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = detectorDacs[ind];
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
+    }
+
+    *retval = dacval;
+    return OK;
+}
+
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    {
+        char *dacNames[] = {DAC_NAMES};
+        LOG(logINFO, ("Setting DAC %s: %d %s \n", dacNames[ind], val,
+                      (mV ? "mV" : "dac units")));
+    }
+
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = val;
+    if (mV) {
+        if (validateDACVoltage(ind, val, mess) == FAIL)
+            return FAIL;
+
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
+            return FAIL;
+    }
+    {
+        char *dacNames[] = {DAC_NAMES};
+        if (LTC2620_D_SetDacValue((int)ind, dacval, dacNames[ind], mess) ==
+            FAIL)
+            return FAIL;
+    }
+    detectorDacs[ind] = dacval;
+
+    // validate settings
     const int specialDacs[NSPECIALDACS] = SPECIALDACINDEX;
     for (int i = 0; i < NSPECIALDACS; ++i) {
         if ((int)ind == specialDacs[i]) {
             validateSettings();
         }
     }
+
+    return OK;
 }
 
-void setVthDac(int index, int enable) {
-    LOG(logINFO, ("\t%s vth%d\n", (enable ? "Enabling" : "Disabing"), index));
-    // enables (from remembered values) or disables vthx
-    enum DACINDEX vthdacs[] = {M_VTH1, M_VTH2, M_VTH3};
-    // disable value
-    int value = DEFAULT_COUNTER_DISABLED_VTH_VAL;
-    // enable, set saved values
-    if (enable) {
-        value = vthEnabledVals[index];
+int getCounterIndexFromDacIndex(enum DACINDEX ind, int *retval_counterIndex,
+                                char *mess) {
+    switch (ind) {
+    case M_VTH1:
+        *retval_counterIndex = 0;
+        return OK;
+    case M_VTH2:
+        *retval_counterIndex = 1;
+        return OK;
+    case M_VTH3:
+        *retval_counterIndex = 2;
+        return OK;
+    default:
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Invalid DAC index %d for threshold DACs\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    setGeneralDAC(vthdacs[index], value, 0);
 }
 
-int getDAC(enum DACINDEX ind, int mV) {
-    if (ind == M_VTHRESHOLD) {
-        int ret = -1, ret1 = -1;
-        // get only for enabled counters
-        uint32_t counters = getCounterMask();
-        int vthdacs[] = {M_VTH1, M_VTH2, M_VTH3};
-        for (int i = 0; i < NCOUNTERS; ++i) {
-            if (counters & (1 << i)) {
-                ret1 = getDAC(vthdacs[i], mV);
-                // first enabled counter
-                if (ret == -1) {
-                    ret = ret1;
-                }
-                // different values for enabled counters
-                else if (ret1 != ret) {
-                    return -1;
-                }
+int setThresholdDACs(int val, bool mV, char *mess) {
+    int indices[] = {M_VTH1, M_VTH2, M_VTH3};
+    uint32_t mask = getCounterMask();
+
+    for (int iCounter = 0; iCounter != NCOUNTERS; ++iCounter) {
+        if (rememberValueIfVthDac(indices[iCounter], val, mV, mess) == FAIL)
+            return FAIL;
+
+        // set value for enabled counter
+        if (mask & (1 << iCounter)) {
+            if (setDAC(indices[iCounter], val, mV, mess) == FAIL)
+                return FAIL;
+        }
+    }
+    return OK;
+}
+
+int getThresholdDACs(bool mV, int *retval, char *mess) {
+    int indices[] = {M_VTH1, M_VTH2, M_VTH3};
+    uint32_t mask = getCounterMask();
+
+    int retvals[NCOUNTERS] = {0};
+    *retval = -1; // default to mismatch
+
+    for (int i = 0; i != NCOUNTERS; ++i) {
+        if (mask & (1 << i)) {
+            if (getDAC(indices[i], mV, &retvals[i], mess) == FAIL)
+                return FAIL;
+            // set retval to first value
+            if (*retval == -1) {
+                *retval = retvals[i];
+            }
+            // other values should match the first value
+            else if (retvals[i] != retvals[0]) {
+                char *dacNames[] = {DAC_NAMES};
+                LOG(logWARNING,
+                    ("Vthreshold mismatch.%s:%d %s:%d\n", dacNames[indices[i]],
+                     retvals[i], dacNames[indices[0]], retvals[0]));
+                *retval = -1;
+                return OK;
             }
         }
-        if (ret == -1) {
-            LOG(logERROR, ("\tvthreshold mismatch (of enabled counters)\n"));
-        } else {
-            LOG(logINFO, ("\tvthreshold match %d\n", ret));
-        }
-        return ret;
     }
-
-    if (!mV) {
-        LOG(logDEBUG1, ("Getting DAC %d : %d dac\n", ind, detectorDacs[ind]));
-        return detectorDacs[ind];
+    if (*retval == -1) {
+        sprintf(mess,
+                "All counters are disabled. Vthreshold value is undefined.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    int voltage = -1;
-    LTC2620_D_DacToVoltage(detectorDacs[ind], &voltage);
-    LOG(logDEBUG1,
-        ("Getting DAC %d : %d dac (%d mV)\n", ind, detectorDacs[ind], voltage));
-    return voltage;
+    LOG(logINFO, ("\tvthreshold match %d\n", *retval));
+    return OK;
 }
 
-int getMaxDacSteps() { return LTC2620_D_GetMaxNumSteps(); }
+int updateValueForVthDac(enum DACINDEX index, int *dacval, char *mess) {
+    // do nothing if not vth dacs
+    if (index != M_VTH1 && index != M_VTH2 && index != M_VTH3) {
+        return OK;
+    }
+    // also validate index: only vth1, vth2, vth3 allowed
+    int iCounter = 0;
+    if (getCounterIndexFromDacIndex(index, &iCounter, mess) == FAIL)
+        return FAIL;
+
+    // remember vth dac
+    if (*dacval != DEFAULT_COUNTER_DISABLED_VTH_VAL) {
+        LOG(logINFO, ("\tRemembering vth%d\n", iCounter + 1));
+        vthEnabledVals[iCounter] = *dacval;
+    }
+
+    // set value for disabled counter
+    uint32_t mask = getCounterMask();
+    if (!(mask & (1 << iCounter))) {
+        *dacval = DEFAULT_COUNTER_DISABLED_VTH_VAL;
+    }
+
+    return OK;
+}
+
+// from user setting dac individually
+int rememberValueIfVthDac(enum DACINDEX index, int val, bool mV, char *mess) {
+    // do nothing if not vth dacs
+    if (index != M_VTH1 && index != M_VTH2 && index != M_VTH3) {
+        return OK;
+    }
+    // also validate index: only vth1, vth2, vth3 allowed
+    int iCounter = 0;
+    if (getCounterIndexFromDacIndex(index, &iCounter, mess) == FAIL)
+        return FAIL;
+
+    if (mV || val != DEFAULT_COUNTER_DISABLED_VTH_VAL) {
+        LOG(logINFO, ("\tRemembering vth%d\n", iCounter + 1));
+        int dacval = val;
+        if (mV) {
+            char *dacNames[] = {DAC_NAMES};
+            if (convertVoltageToDACValue(index, val, &dacval, mess) == FAIL) {
+                LOG(logERROR,
+                    ("Could not convert voltage to dac value for %s\n",
+                     dacNames[index]));
+                return FAIL;
+            }
+        }
+        vthEnabledVals[iCounter] = dacval;
+    }
+    return OK;
+}
+
+int setVthEnabled(enum DACINDEX index, bool enable, char *mess) {
+    // alsovalidate index: only vth1, vth2, vth3 allowed
+    int iCounter = 0;
+    if (getCounterIndexFromDacIndex(index, &iCounter, mess) == FAIL)
+        return FAIL;
+
+    LOG(logINFO,
+        ("\t%s vth%d\n", (enable ? "Enabling" : "Disabling"), iCounter + 1));
+    int value = DEFAULT_COUNTER_DISABLED_VTH_VAL;
+    if (enable)
+        value = vthEnabledVals[iCounter];
+    return setDAC(index, value, false, mess);
+}
 
 int getADC(enum ADCINDEX ind, int *value) {
     LOG(logDEBUG1, ("Reading FPGA temperature...\n"));
@@ -1692,17 +1838,39 @@ int getADC(enum ADCINDEX ind, int *value) {
     return OK;
 }
 
-int setHighVoltage(int val) {
-    // limit values
-    if (val > HV_SOFT_MAX_VOLTAGE) {
-        val = HV_SOFT_MAX_VOLTAGE;
+int setHighVoltage(int val, char *mess) {
+    // validate input value
+    if (val < 0 || val > HV_SOFT_MAX_VOLTAGE) {
+        sprintf(mess, "Invalid Voltage. Valid range (0 - %d)\n",
+                HV_SOFT_MAX_VOLTAGE);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
     LOG(logINFO, ("Setting High voltage: %d V\n", val));
-    return DAC6571_Set(val);
+    if (DAC6571_Set(val, mess) == FAIL) {
+        return FAIL;
+    }
+
+    // validate get
+    int retval = 0;
+    if (getHighVoltage(&retval, mess) == FAIL)
+        return FAIL;
+    if (val != retval) {
+        sprintf(mess, "Could not set high voltage. Set %d, but got %d\n", val,
+                retval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    return OK;
 }
 
-int getHighVoltage(int *retval) { return DAC6571_Get(retval); }
+int getHighVoltage(int *retval, char *mess) {
+    int ret = DAC6571_Get(retval, mess);
+    LOG(logDEBUG1, ("High Voltage: %d\n", *retval));
+    return ret;
+}
 
 /* parameters - timing */
 
@@ -1809,27 +1977,75 @@ int setGainCaps(int caps) {
     return setChipStatusRegister(csr);
 }
 
-int setInterpolation(int enable) {
+int setInterpolation(bool enable, char *mess) {
     LOG(logINFO,
         ("%s Interpolation\n", enable == 0 ? "Disabling" : "Enabling"));
 
-    int csr = M3SetInterpolation(enable);
-    int ret = setChipStatusRegister(csr);
-    if (ret == OK) {
-        updateVthAndCounterMask();
+    if (getPumpProbe() && enable) {
+        snprintf(
+            mess, MAX_STR_LENGTH,
+            "Could not set interpolation. Disable pump probe mode first.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    return ret;
+
+    int csr = M3SetInterpolation(enable);
+    if (setChipStatusRegister(csr) == FAIL) {
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not set interpolation to %d. Setting chip status "
+                 "register failed.\n",
+                 enable);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    if (updateVthAndCounterMask(mess) == FAIL)
+        return FAIL;
+
+    bool retval = getInterpolation();
+    if (retval != enable) {
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not set interpolation to %d. Current value is %d\n",
+                 enable, retval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
 }
 
-int setPumpProbe(int enable) {
+int setPumpProbe(bool enable, char *mess) {
     LOG(logINFO, ("%s Pump Probe\n", enable == 0 ? "Disabling" : "Enabling"));
 
-    int csr = M3SetPumpProbe(enable);
-    int ret = setChipStatusRegister(csr);
-    if (ret == OK) {
-        updateVthAndCounterMask();
+    if (getInterpolation() && enable) {
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not set pump probe mode. Disable interpolation mode "
+                 "first.\n");
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    return ret;
+
+    int csr = M3SetPumpProbe(enable);
+    if (setChipStatusRegister(csr) == FAIL) {
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not set pump probe to %d. Setting chip status register "
+                 "failed.\n",
+                 enable);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    if (updateVthAndCounterMask(mess) == FAIL)
+        return FAIL;
+
+    bool retval = getPumpProbe();
+    if (retval != enable) {
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not set pump probe to %d. Current value is %d\n",
+                 enable, retval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
 }
 
 int setDigitalPulsing(int enable) {

slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.h

@@ -7,6 +7,7 @@
 #include "nios.h"
 #include "programViaNios.h"
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -67,7 +68,7 @@ void initStopServer();
 // set up detector
 int allocateDetectorStructureMemory();
 void setupDetector();
-int resetToDefaultDacs(int hardReset);
+int resetToDefaultDacs(int hardReset, char *mess);
 int getDefaultDac(enum DACINDEX index, enum detectorSettings sett, int *retval);
 int setDefaultDac(enum DACINDEX index, enum detectorSettings sett, int value);
 void setASICDefaults();
@@ -104,8 +105,9 @@ int64_t getExpTime(int gateIndex);
 int setGateDelay(int gateIndex, int64_t val);
 int64_t getGateDelay(int gateIndex);
 
-void setCounterMask(uint32_t arg);
-void setCounterMaskWithUpdateFlag(uint32_t arg, int updateMaskFlag);
+int updateVthAndCounterMask(char *mess);
+int setCounterMask(uint32_t arg, char *mess);
+int setCounterMaskAndTimeRegisters(uint32_t arg, char *mess);
 uint32_t getCounterMask();
 void updatePacketizing();
 
@@ -125,7 +127,7 @@ int setModule(sls_detector_module myMod, char *mess);
 int setTrimbits(int *trimbits);
 int setAllTrimbits(int val);
 int getAllTrimbits();
-enum detectorSettings setSettings(enum detectorSettings sett);
+int setSettings(enum detectorSettings sett, char *mess);
 enum detectorSettings getSettings();
 
 // parameters - threshold
@@ -133,15 +135,31 @@ int getThresholdEnergy(int counterIndex);
 void setThresholdEnergy(int counterIndex, int eV);
 
 // parameters - dac, adc, hv
-void setDAC(enum DACINDEX ind, int val, int mV, int counterEnableCheck);
-void setGeneralDAC(enum DACINDEX ind, int val, int mV);
-void setVthDac(int index, int enable);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
+
+int getCounterIndexFromDacIndex(enum DACINDEX ind, int *retval_counterIndex,
+                                char *mess);
+int setSingleThresholdDAC(enum DACINDEX ind, int val, bool mV, int dacval,
+                          bool counterCheck, char *mess);
+int setThresholdDACs(int val, bool mV, char *mess);
+int getThresholdDACs(bool mV, int *retval, char *mess);
+
+/** If 1 */
+int updateValueForVthDac(enum DACINDEX index, int *dacval, char *mess);
+int rememberValueIfVthDac(enum DACINDEX index, int val, bool mV, char *mess);
+int setVthEnabled(enum DACINDEX index, bool enable, char *mess);
 
 int getADC(enum ADCINDEX ind, int *value);
-int setHighVoltage(int val);
-int getHighVoltage(int *retval);
+int setHighVoltage(int val, char *mess);
+int getHighVoltage(int *retval, char *mess);
 
 // parameters - timing, extsig
 int isMaster(int *retval);
@@ -150,12 +168,11 @@ enum timingMode getTiming();
 void setInitialExtSignals();
 int setChipStatusRegister(int csr);
 int setGainCaps(int caps);
-int setInterpolation(int enable);
-int setPumpProbe(int enable);
+int setInterpolation(bool enable, char *mess);
+int setPumpProbe(bool enable, char *mess);
 int setDigitalPulsing(int enable);
 int setAnalogPulsing(int enable);
 int setNegativePolarity(int enable);
-int setDACS(int *dacs);
 void setExtSignal(int signalIndex, enum externalSignalFlag mode);
 int getExtSignal(int signalIndex);
 

slsDetectorServers/slsDetectorServer/include/AD9257.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <inttypes.h>
+#include <stdbool.h>
 
 #ifdef JUNGFRAUD
 void AD9257_Set_Jungfrau_Hardware_Version_1_0(int val);
@@ -27,7 +28,7 @@ void AD9257_Disable();
 /**
  * Get vref voltage
  */
-int AD9257_GetVrefVoltage(int mV);
+int AD9257_GetVrefVoltage(bool mV);
 
 /**
  * Set vref voltage
@@ -35,7 +36,7 @@ int AD9257_GetVrefVoltage(int mV);
  * for 1.6V, 4 for 2.0V
  * @returns ok or fail
  */
-int AD9257_SetVrefVoltage(int val, int mV);
+int AD9257_SetVrefVoltage(int val, bool mV);
 
 /**
  * Set SPI reg value

slsDetectorServers/slsDetectorServer/include/DAC6571.h

@@ -5,5 +5,5 @@
 #include <inttypes.h>
 
 void DAC6571_SetDefines(int hardMaxV, char *driverfname);
-int DAC6571_Set(int val);
-int DAC6571_Get(int *retval);
+int DAC6571_Set(int val, char *mess);
+int DAC6571_Get(int *retval, char *mess);

slsDetectorServers/slsDetectorServer/include/LTC2620.h

@@ -103,18 +103,11 @@ void LTC2620_Set(int cmd, int data, int dacaddr, int chipIndex);
 void LTC2620_Configure();
 
 /**
- * Set Dac (obtains dacaddr, command and ichip and calls LTC2620_Set)
+ * Sets the ichip, address and command, Calls LTC2620_Set)
  * @param dacnum dac number
  * @param data dac value to set
  */
 void LTC2620_SetDAC(int dacnum, int data);
 
-/**
- * Set dac in dac units or mV
- * @param dacnum dac index
- * @param val value in dac units or mV
- * @param mV 0 for dac units and 1 for mV unit
- * @param dacval pointer to value in dac units
- * @returns OK or FAIL for success of operation
- */
-int LTC2620_SetDACValue(int dacnum, int val, int mV, int *dacval);
+/** From  */
+int LTC2620_SetDacValue(int dacnum, int val, char *dacname, char *mess);

slsDetectorServers/slsDetectorServer/include/LTC2620_Driver.h

@@ -28,14 +28,4 @@ int LTC2620_D_VoltageToDac(int voltage, int *dacval);
  */
 int LTC2620_D_DacToVoltage(int dacval, int *voltage);
 
-/**
- * Set value
- * @param dacnum dac index
- * @param val value to set
- * @param mV 1 for mv, else 0
- * @paam dacname dac name
- * @param dacval pointer to dac value
- * @return OK or FAIL
- */
-int LTC2620_D_SetDACValue(int dacnum, int val, int mV, char *dacname,
-                          int *dacval);
+int LTC2620_D_SetDacValue(int dacnum, int val, char *dacname, char *mess);

slsDetectorServers/slsDetectorServer/include/MAX1932.h

@@ -17,14 +17,5 @@
 void MAX1932_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk,
                         uint32_t dmsk, int dofst, int minMV, int maxMV);
 
-/**
- * Disable SPI
- */
 void MAX1932_Disable();
-
-/**
- * Set value (value is updated to correct range)
- * @param val pointer to value to set
- * @return OK or FAIL
- */
-int MAX1932_Set(int *val);
+int MAX1932_Set(int val, char *mess);

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -4,6 +4,7 @@
 #include "clogger.h"
 #include "common.h"
 #include "sls/sls_detector_defs.h"
+#include <stdbool.h>
 
 #define GOODBYE (-200)
 #define REBOOT  (-400)
@@ -39,7 +40,7 @@ int set_bus_test(int);
 int set_image_test_mode(int);
 int get_image_test_mode(int);
 enum DACINDEX getDACIndex(enum dacIndex ind);
-int validateAndSetDac(enum dacIndex ind, int val, int mV);
+int processDACEnums(enum dacIndex ind, int val, bool mV);
 int set_dac(int);
 int get_adc(int);
 int write_register(int);

slsDetectorServers/slsDetectorServer/src/AD9257.c

@@ -194,8 +194,8 @@ void AD9257_Disable() {
                           ~(AD9257_DigMask));
 }
 
-int AD9257_GetVrefVoltage(int mV) {
-    if (mV == 0)
+int AD9257_GetVrefVoltage(bool mV) {
+    if (!mV)
         return AD9257_VrefVoltage;
     switch (AD9257_VrefVoltage) {
     case 0:
@@ -214,7 +214,7 @@ int AD9257_GetVrefVoltage(int mV) {
     }
 }
 
-int AD9257_SetVrefVoltage(int val, int mV) {
+int AD9257_SetVrefVoltage(int val, bool mV) {
     int mode = val;
     // convert to mode
     if (mV) {

slsDetectorServers/slsDetectorServer/src/DAC6571.c

@@ -30,18 +30,23 @@ void DAC6571_SetDefines(int hardMaxV, char *driverfname) {
 #endif
 }
 
-int DAC6571_Set(int val) {
+int DAC6571_Set(int val, char *mess) {
     LOG(logDEBUG1, ("Setting high voltage to %d\n", val));
-    if (val < 0)
+    if (val < 0) {
+        sprintf(mess, "Invalid value. Cannot be negative.\n");
+        LOG(logERROR, (mess));
         return FAIL;
+    }
 
     int dacvalue = 0;
 
     // convert value
     if (ConvertToDifferentRange(0, DAC6571_HardMaxVoltage, DAC6571_MIN_DAC_VAL,
                                 DAC6571_MAX_DAC_VAL, val, &dacvalue) == FAIL) {
-        LOG(logERROR,
-            ("Could not convert %d high voltage to a valid dac value\n", val));
+        sprintf(mess,
+                "Could not convert %d high voltage to a valid dac value\n",
+                val);
+        LOG(logERROR, (mess));
         return FAIL;
     }
     LOG(logINFO, ("\t%dV (dacval %d)\n", val, dacvalue));
@@ -52,9 +57,10 @@ int DAC6571_Set(int val) {
     // open file
     FILE *fd = fopen(DAC6571_DriverFileName, "w");
     if (fd == NULL) {
-        LOG(logERROR,
-            ("Could not open file %s for writing to set high voltage\n",
-             DAC6571_DriverFileName));
+        sprintf(mess,
+                "Could not open file %s for writing to set high voltage\n",
+                DAC6571_DriverFileName);
+        LOG(logERROR, (mess));
         return FAIL;
     }
     // convert to string, add 0 and write to file
@@ -65,7 +71,7 @@ int DAC6571_Set(int val) {
     return OK;
 }
 
-int DAC6571_Get(int *retval) {
+int DAC6571_Get(int *retval, char *mess) {
     LOG(logDEBUG1, ("Getting high voltage\n"));
     int dacvalue = 0;
 
@@ -74,7 +80,8 @@ int DAC6571_Get(int *retval) {
 #else
     if (readParameterFromFile(DAC6571_DriverFileName, "high voltage",
                               &dacvalue) == FAIL) {
-        LOG(logERROR, ("Could not get high voltage\n"));
+        sprintf(mess, "Could not get high voltage\n");
+        LOG(logERROR, (mess));
         return FAIL;
     }
 #endif
@@ -83,9 +90,10 @@ int DAC6571_Get(int *retval) {
     if (ConvertToDifferentRange(DAC6571_MIN_DAC_VAL, DAC6571_MAX_DAC_VAL, 0,
                                 DAC6571_HardMaxVoltage, dacvalue,
                                 retval) == FAIL) {
-        LOG(logERROR,
-            ("Could not convert %d dac value to a valid high voltage\n",
-             dacvalue));
+        sprintf(mess,
+                "Could not convert %d dac value to a valid high voltage\n",
+                dacvalue);
+        LOG(logERROR, (mess));
         return FAIL;
     }
     LOG(logINFO, ("\t%dV (dacval %d)\n", (*retval), dacvalue));
@@ -94,9 +102,10 @@ int DAC6571_Get(int *retval) {
     // open file
     FILE *fd = fopen(DAC6571_DriverFileName, "w");
     if (fd == NULL) {
-        LOG(logERROR,
-            ("Could not open file %s for writing to set high voltage\n",
-             DAC6571_DriverFileName));
+        sprintf(mess,
+                "Could not open file %s for writing to get high voltage\n",
+                DAC6571_DriverFileName);
+        LOG(logERROR, (mess));
         return FAIL;
     }
     // convert to string, add 0 and write to file

slsDetectorServers/slsDetectorServer/src/LTC2620.c

@@ -222,48 +222,37 @@ void LTC2620_SetDAC(int dacnum, int data) {
     LTC2620_Set(cmd, data, addr, ichip);
 }
 
-int LTC2620_SetDACValue(int dacnum, int val, int mV, int *dacval) {
-    LOG(logDEBUG1, ("dacnum:%d, val:%d, ismV:%d\n", dacnum, val, mV));
+int LTC2620_SetDacValue(int dacnum, int val, char *dacname, char *mess) {
+    LOG(logDEBUG1, ("dacnum:%s [%d], val:%d\n", dacname, dacnum, val));
     // validate index
     if (dacnum < 0 || dacnum >= LTC2620_Ndac) {
-        LOG(logERROR, ("Dac index %d is out of bounds (0 to %d)\n", dacnum,
-                       LTC2620_Ndac - 1));
+        snprintf(mess, MAX_STR_LENGTH, "Could not set DAC. Invalid index %d\n",
+                 dacnum);
+        LOG(logERROR, (mess));
         return FAIL;
     }
-
-    // get
-    if (val < 0 && val != LTC2620_PWR_DOWN_VAL)
+    // validate min value
+    if (val < 0 && val != LTC2620_PWR_DOWN_VAL) {
+        snprintf(
+            mess, MAX_STR_LENGTH,
+            "Could not set DAC %s [%d]. Input value %d must be positive or %d "
+            "(power down)\n",
+            dacname, dacnum, val, LTC2620_PWR_DOWN_VAL);
+        LOG(logERROR, (mess));
         return FAIL;
-
-    // convert to dac or get mV value
-    *dacval = val;
-    int dacmV = val;
-    int ret = OK;
-    int ndacsonly = LTC2620_Ndac;
-#ifdef CHIPTESTBOARDD
-    ndacsonly = NDAC_ONLY;
+    }
+    // validate maxvalue
+    if (val > LTC2620_MAX_VAL) {
+        snprintf(
+            mess, MAX_STR_LENGTH,
+            "Could not set DAC %s [%d]. Input value %d exceeds maximum %d.\n",
+            dacname, dacnum, val, LTC2620_MAX_VAL);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    LOG(logINFO, ("\tSetting DAC %s [%d]: %d dac\n", dacname, dacnum, val));
+#ifndef VIRTUAL
+    LTC2620_SetDAC(dacnum, val);
 #endif
-    if (mV) {
-        ret = LTC2620_VoltageToDac(val, dacval);
-    } else if (val >= 0 && dacnum <= ndacsonly) {
-        // do not convert power down dac val
-        //(if not ndacsonly (pwr/vchip): dont need to print mV value as it will
-        // be wrong (wrong limits))
-        ret = LTC2620_DacToVoltage(val, &dacmV);
-    }
-
-    // conversion out of bounds
-    if (ret == FAIL) {
-        LOG(logERROR, ("Setting Dac %d %s is out of bounds\n", dacnum,
-                       (mV ? "mV" : "dac units")));
-        return FAIL;
-    }
-
-    // set
-    if ((*dacval >= 0) || (*dacval == LTC2620_PWR_DOWN_VAL)) {
-        LOG(logINFO,
-            ("Setting DAC %d: %d dac (%d mV)\n", dacnum, *dacval, dacmV));
-        LTC2620_SetDAC(dacnum, *dacval);
-    }
     return OK;
 }

slsDetectorServers/slsDetectorServer/src/LTC2620_Driver.c

@@ -58,109 +58,66 @@ int LTC2620_D_DacToVoltage(int dacval, int *voltage) {
                                    LTC2620_D_HardMaxVoltage, dacval, voltage);
 }
 
-int LTC2620_D_SetDACValue(int dacnum, int val, int mV, char *dacname,
-                          int *dacval) {
-    LOG(logDEBUG1, ("dacnum:%d, val:%d, ismV:%d\n", dacnum, val, mV));
-
+int LTC2620_D_SetDacValue(int dacnum, int val, char *dacname, char *mess) {
+    LOG(logDEBUG1, ("dacnum:%s [%d], val:%d\n", dacname, dacnum, val));
     // validate index
     if (dacnum < 0 || dacnum >= LTC2620_D_NumDacs) {
-        LOG(logERROR, ("Dac index %d is out of bounds (0 to %d)\n", dacnum,
-                       LTC2620_D_NumDacs - 1));
+        snprintf(mess, MAX_STR_LENGTH, "Could not set DAC. Invalid index %d\n",
+                 dacnum);
+        LOG(logERROR, (mess));
         return FAIL;
     }
-
-    // validate set
-    if (val < 0 && val != LTC2620_D_PWR_DOWN_VAL)
+    // validate min value
+    if (val < 0 && val != LTC2620_D_PWR_DOWN_VAL) {
+        snprintf(
+            mess, MAX_STR_LENGTH,
+            "Could not set DAC %s [%d]. Input value %d must be positive or %d "
+            "(power down)\n",
+            dacname, dacnum, val, LTC2620_D_PWR_DOWN_VAL);
+        LOG(logERROR, (mess));
         return FAIL;
+    }
+    // validate maxvalue
+    if (val > LTC2620_D_MAX_DAC_VAL) {
+        snprintf(
+            mess, MAX_STR_LENGTH,
+            "Could not set DAC %s [%d]. Input value %d exceeds maximum %d.\n",
+            dacname, dacnum, val, LTC2620_D_MAX_DAC_VAL);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    LOG(logINFO, ("\tSetting DAC %s [%d]: %d dac\n", dacname, dacnum, val));
 
-    int ret = OK;
-    *dacval = val;
-#ifndef VIRTUAL
+#ifdef VIRTUAL
+    return OK;
+#else
+    // fname to write to
+    char fname[MAX_STR_LENGTH];
+    memset(fname, 0, MAX_STR_LENGTH);
     char fnameFormat[MAX_STR_LENGTH];
     memset(fnameFormat, 0, MAX_STR_LENGTH);
     strcpy(fnameFormat, LTC2620_D_DriverFileName);
-#endif
-
-    // power down dac (different file name)
-    if (val == LTC2620_D_PWR_DOWN_VAL) {
-#if defined(XILINX_CHIPTESTBOARDD) && !defined(VIRTUAL)
-        LOG(logINFO, ("Powering down DAC %2d [%-6s] \n", dacnum, dacname));
-        strcpy(fnameFormat, LTC2620_D_PowerDownDriverFileName);
-#endif
-    }
-
-    // proper value to set
-    else {
-        // convert to dac or get mV value
-        int dacmV = val;
-        if (mV) {
-            ret = LTC2620_D_VoltageToDac(val, dacval);
-        }
-
-        // mV only for print out (dont convert to mV for power regulators)
-        else if (val >= 0 && dacnum < LTC2620_D_NumDacsOnly) {
-            // do not convert power down dac val
-            ret = LTC2620_D_DacToVoltage(val, &dacmV);
-        }
-
-        // conversion out of bounds
-        if (ret == FAIL) {
-            LOG(logERROR, ("Setting Dac %d %s is out of bounds\n", dacnum,
-                           (mV ? "mV" : "dac units")));
-            return FAIL;
-        }
-
-        // print and set
-#ifdef XILINX_CHIPTESTBOARDD
-        if (*dacval >= 0) {
-            // also print mV
-            if (dacnum < LTC2620_D_NumDacsOnly) {
-                LOG(logINFO, ("Setting DAC %2d [%-6s] : %d dac (%d mV)\n",
-                              dacnum, dacname, *dacval, dacmV));
-            }
-            // do not print mV for power regulators
-            else {
-                LOG(logINFO, ("Setting Power DAC%2d [%-6s] : %d dac \n", dacnum,
-                              dacname, *dacval));
-            }
-        }
-#else
-        if ((*dacval >= 0) || (*dacval == LTC2620_D_PWR_DOWN_VAL)) {
-            LOG(logINFO, ("Setting DAC %2d [%-12s] : %d dac (%d mV)\n", dacnum,
-                          dacname, *dacval, dacmV));
-        }
-#endif
-    }
-
-    // set in file
-#ifndef VIRTUAL
-    char fname[MAX_STR_LENGTH];
-    memset(fname, 0, MAX_STR_LENGTH);
-#ifdef XILINX_CHIPTESTBOARDD
-    sprintf(fname, fnameFormat, dacnum);
-#else
     sprintf(fname, "%s%d", fnameFormat, dacnum);
+#if defined(XILINX_CHIPTESTBOARDD)
+    if (val == LTC2620_D_PWR_DOWN_VAL) {
+        strcpy(fnameFormat, LTC2620_D_PowerDownDriverFileName);
+        val = 1; //-100?:Invalid Argument
+    }
+    sprintf(fname, fnameFormat, dacnum);
 #endif
     LOG(logDEBUG1, ("fname %s\n", fname));
 
     // open file
     FILE *fd = fopen(fname, "w");
     if (fd == NULL) {
-        LOG(logERROR, ("Could not open file %s for writing to set dac %d\n",
-                       fname, dacnum));
+        snprintf(mess, MAX_STR_LENGTH,
+                 "Could not open file %s for writing to set DAC %s[%d]\n",
+                 fname, dacname, dacnum);
+        LOG(logERROR, (mess));
         return FAIL;
     }
-    // convert to string, add 0 and write to file
-#ifdef XILINX_CHIPTESTBOARDD
-    // not changing *dacval from -100 (cant write -100 to file: invalid arg)
-    int writeValue = *dacval;
-    if (writeValue == LTC2620_D_PWR_DOWN_VAL)
-        writeValue = 1;
-    fprintf(fd, "%d\n", writeValue);
-#else
-    fprintf(fd, "%d\n", *dacval);
-#endif
+    fprintf(fd, "%d\n", val);
     fclose(fd);
-#endif
     return OK;
+#endif
 }

slsDetectorServers/slsDetectorServer/src/MAX1932.c

@@ -43,33 +43,33 @@ void MAX1932_Disable() {
                            ~(MAX1932_DigMask));
 }
 
-int MAX1932_Set(int *val) {
-    LOG(logDEBUG1, ("Setting high voltage to %d\n", *val));
-    if (*val < 0)
-        return FAIL;
-
-    int dacvalue = 0;
+int MAX1932_Set(int val, char *mess) {
+    LOG(logDEBUG1, ("Setting high voltage to %d\n", val));
 
     // limit values (normally < 60 => 0 (off))
-    if (*val < MAX1932_MinVoltage) {
+    if ((val != 0 && val < MAX1932_MinVoltage) || val > MAX1932_MaxVoltage) {
+        sprintf(mess,
+                "Could not set high voltage. Invalid value:%d. Should bet be 0 "
+                "or between %d and %d\n",
+                val, MAX1932_MinVoltage, MAX1932_MaxVoltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    int dacvalue = 0;
+    if (val == 0)
         dacvalue = MAX1932_POWER_OFF_DAC_VAL;
-        *val = 0;
+    else if (ConvertToDifferentRange(MAX1932_MinVoltage, MAX1932_MaxVoltage,
+                                     MAX1932_MIN_DAC_VAL, MAX1932_MAX_DAC_VAL,
+                                     val, &dacvalue) == FAIL) {
+        sprintf(
+            mess,
+            "Could not set high voltage %d. Could not convert to dac units\n",
+            val);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
-    // limit values (normally > 200 => 0x1 (max))
-    else if (*val > MAX1932_MaxVoltage) {
-        dacvalue = MAX1932_MAX_DAC_VAL;
-        *val = MAX1932_MaxVoltage;
-    }
-    // convert value
-    else {
-        // no failure in conversion as limits handled (range from 0x1 to 0xFF)
-        ConvertToDifferentRange(MAX1932_MinVoltage, MAX1932_MaxVoltage,
-                                MAX1932_MIN_DAC_VAL, MAX1932_MAX_DAC_VAL, *val,
-                                &dacvalue);
-        dacvalue &= MAX1932_HV_DATA_MSK;
-    }
-
-    LOG(logINFO, ("\t%dV (dacval %d)\n", *val, dacvalue));
+    dacvalue &= MAX1932_HV_DATA_MSK;
+    LOG(logINFO, ("\t%dV (dacval %d)\n", val, dacvalue));
     serializeToSPI(MAX1932_Reg, dacvalue, MAX1932_CsMask, MAX1932_HV_NUMBITS,
                    MAX1932_ClkMask, MAX1932_DigMask, MAX1932_DigOffset, 0);
     return OK;

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -1159,299 +1159,320 @@ enum DACINDEX getDACIndex(enum dacIndex ind) {
     return serverDacIndex;
 }
 
-int validateAndSetDac(enum dacIndex ind, int val, int mV) {
+#ifdef EIGERD
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
     int retval = -1;
-
     enum DACINDEX serverDacIndex = 0;
-    // valid enums
     switch (ind) {
-#ifndef XILINX_CHIPTESTBOARDD
-    case HIGH_VOLTAGE:
-#endif
-#ifdef EIGERD
-    case IO_DELAY:
-#elif CHIPTESTBOARDD
-    case ADC_VPP:
-    case V_LIMIT:
-#elif XILINX_CHIPTESTBOARDD
-    case V_LIMIT:
-#endif
-        break;
-    default:
-        serverDacIndex = getDACIndex(ind);
-        break;
-    }
-    if (ret == FAIL) {
-        return retval;
-    }
-    switch (ind) {
-        // adc vpp
-#if defined(CHIPTESTBOARDD)
-    case ADC_VPP:
-        // set
-        if (val >= 0) {
-            ret = AD9257_SetVrefVoltage(val, mV);
-            if (ret == FAIL) {
-                sprintf(mess, "Could not set Adc Vpp. Please set a "
-                              "proper value\n");
-                LOG(logERROR, (mess));
-            }
-        }
-        retval = AD9257_GetVrefVoltage(mV);
-        LOG(logDEBUG1,
-            ("Adc Vpp retval: %d %s\n", retval, (mV ? "mV" : "mode")));
-        // cannot validate (its just a variable and mv gives different
-        // value)
-        break;
-#endif
 
-        // io delay
-#ifdef EIGERD
     case IO_DELAY:
         retval = setIODelay(val);
         LOG(logDEBUG1, ("IODelay: %d\n", retval));
         validate(&ret, mess, val, retval, "set iodelay", DEC);
-        break;
-#endif
+        return retval;
 
-        // high voltage
-#ifndef XILINX_CHIPTESTBOARDD
     case HIGH_VOLTAGE:
+        if (val != GET_FLAG)
+            ret = setHighVoltage(val, mess);
+        else
+            ret = getHighVoltage(&retval, mess);
+        return retval;
 
-#if defined(MYTHEN3D) || defined(GOTTHARD2D)
-        if ((val != -1 && val < 0) || (val > HV_SOFT_MAX_VOLTAGE)) {
-            ret = FAIL;
-            sprintf(mess, "Invalid Voltage. Valid range (0 - %d)\n",
-                    HV_SOFT_MAX_VOLTAGE);
-            LOG(logERROR, (mess));
-        } else {
-            if (val >= 0) {
-                ret = setHighVoltage(val);
-                if (ret == FAIL) {
-                    strcpy(mess, "Could not set high voltage.\n");
-                    LOG(logERROR, (mess));
-                }
-            }
-            if (ret == OK) {
-                ret = getHighVoltage(&retval);
-                if (ret == FAIL) {
-                    strcpy(mess, "Could not get high voltage.\n");
-                    LOG(logERROR, (mess));
-                }
-                LOG(logDEBUG1, ("High Voltage: %d\n", retval));
-                validate(&ret, mess, val, retval, "set high voltage", DEC);
+        // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        // set
+        if (val != GET_FLAG) {
+            ret = setDAC(serverDacIndex, val, mV, mess);
+            // handle if set by user individually
+            if (serverDacIndex == E_VCMP_LL || serverDacIndex == E_VCMP_LR ||
+                serverDacIndex == E_VCMP_RL || serverDacIndex == E_VCMP_RR ||
+                serverDacIndex == E_VRPREAMP || serverDacIndex == E_VCP) {
+                setSettings(UNDEFINED, mess);
+                LOG(logERROR, ("Settings has been changed "
+                               "to undefined (changed specific dacs)\n"));
             }
         }
-#else
-        retval = setHighVoltage(val);
-        LOG(logDEBUG1, ("High Voltage: %d\n", retval));
-#if defined(JUNGFRAUD) || defined(MOENCHD) || defined(CHIPTESTBOARDD)
-        validate(&ret, mess, val, retval, "set high voltage", DEC);
-#endif
+        // get
+        else
+            ret = getDAC(serverDacIndex, mV, &retval, mess);
+        return retval;
+    }
+}
 #endif
 
-#ifdef EIGERD
-        if ((retval != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval < 0)) {
-            ret = FAIL;
-            if (retval == -1)
-                sprintf(mess,
-                        "Setting high voltage failed. Bad value %d. "
-                        "The range is from 0 to 200 V.\n",
-                        val);
-            else if (retval == -2)
-                strcpy(mess, "Setting high voltage failed. "
-                             "Serial/i2c communication failed.\n");
-            else if (retval == -3)
-                strcpy(mess, "Getting high voltage failed. "
-                             "Serial/i2c communication failed.\n");
-            LOG(logERROR, (mess));
+#if MYTHEN3D
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
+    int retval = -1;
+    enum DACINDEX serverDacIndex = 0;
+    switch (ind) {
+
+    case HIGH_VOLTAGE:
+        if (val != GET_FLAG)
+            ret = setHighVoltage(val, mess);
+        else
+            ret = getHighVoltage(&retval, mess);
+        return retval;
+
+    // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        // set
+        if (val != GET_FLAG) {
+            if ((int)serverDacIndex == (int)M_VTHRESHOLD)
+                ret = setThresholdDACs(val, mV, mess);
+            else {
+                ret = rememberValueIfVthDac(serverDacIndex, val, mV, mess);
+                if (ret == FAIL)
+                    return retval;
+                ret = setDAC(serverDacIndex, val, mV, mess);
+                // changed for setsettings (direct),
+                // custom trimbit file (setmodule with myMod.reg as -1),
+                // change of dac (direct)
+                if (ret == OK) {
+                    for (int i = 0; i < NCOUNTERS; ++i) {
+                        setThresholdEnergy(i, -1);
+                    }
+                }
+            }
         }
+        // get
+        else {
+            if ((int)serverDacIndex == (int)M_VTHRESHOLD)
+                ret = getThresholdDACs(mV, &retval, mess);
+            else
+                ret = getDAC(serverDacIndex, mV, &retval, mess);
+        }
+        return retval;
+    }
+}
 #endif
-        break;
+
+#if GOTTHARD2D
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
+    int retval = -1;
+    enum DACINDEX serverDacIndex = 0;
+    switch (ind) {
+
+    case HIGH_VOLTAGE:
+        if (val != GET_FLAG)
+            ret = setHighVoltage(val, mess);
+        else
+            ret = getHighVoltage(&retval, mess);
+        return retval;
+
+    // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        if (val != GET_FLAG)
+            ret = setDAC(serverDacIndex, val, mV, mess);
+        else
+            ret = getDAC(serverDacIndex, mV, &retval, mess);
+        return retval;
+    }
+}
 #endif
-        // power
-#if defined(CHIPTESTBOARDD) || defined(XILINX_CHIPTESTBOARDD)
+
+#if JUNGFRAUD
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
+    int retval = -1;
+    enum DACINDEX serverDacIndex = 0;
+    switch (ind) {
+
+    case HIGH_VOLTAGE:
+        if (val != GET_FLAG)
+            ret = setHighVoltage(val, mess);
+        else
+            ret = getHighVoltage(&retval, mess);
+        return retval;
+
+    // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        if (val != GET_FLAG)
+            ret = setDAC(serverDacIndex, val, mV, mess);
+        else
+            ret = getDAC(serverDacIndex, mV, &retval, mess);
+        return retval;
+    }
+}
+#endif
+
+#if MOENCHD
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
+    int retval = -1;
+    enum DACINDEX serverDacIndex = 0;
+    switch (ind) {
+
+    case HIGH_VOLTAGE:
+        if (val != GET_FLAG)
+            ret = setHighVoltage(val, mess);
+        else
+            ret = getHighVoltage(&retval, mess);
+        return retval;
+
+    // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        if (val != GET_FLAG)
+            ret = setDAC(serverDacIndex, val, mV, mess);
+        else
+            ret = getDAC(serverDacIndex, mV, &retval, mess);
+        return retval;
+    }
+}
+#endif
+
+#if CHIPTESTBOARDD
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
+    int retval = -1;
+    enum DACINDEX serverDacIndex = 0;
+    switch (ind) {
+
+    case ADC_VPP:
+        if (val != GET_FLAG)
+            ret = setADCVpp(val, mV, mess);
+        else
+            ret = getADCVpp(mV, &retval, mess);
+        return retval;
+
+    case HIGH_VOLTAGE:
+        if (val != GET_FLAG)
+            ret = setHighVoltage(val, mess);
+        else
+            ret = getHighVoltage(&retval, mess);
+        return retval;
+
+    case V_POWER_CHIP:
+        if (val != GET_FLAG) {
+            ret = FAIL;
+            sprintf(
+                mess,
+                "Can not set Vchip. Can only be set automatically in the "
+                "background (+200mV from highest power regulator voltage).\n");
+            LOG(logERROR, (mess));
+            return retval;
+        }
+        ret = getVchip(&retval, mess);
+        return retval;
+
+    case V_LIMIT:
+        if (val != GET_FLAG) {
+            if (!mV) {
+                ret = FAIL;
+                strcpy(mess, "Could not set vlimit. VLimit should be in "
+                             "mV and not dac units.\n");
+                LOG(logERROR, (mess));
+                return retval;
+            }
+            ret = setVLimit(val, mess);
+        } else
+            retval = getVLimit();
+        return retval;
+
     case V_POWER_A:
     case V_POWER_B:
     case V_POWER_C:
     case V_POWER_D:
     case V_POWER_IO:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
         if (val != GET_FLAG) {
             if (!mV) {
                 ret = FAIL;
                 sprintf(mess,
-                        "Could not set power. Power regulator %d "
-                        "should be in mV and not dac units.\n",
+                        "Could not set power. Power regulator %d should be in "
+                        "mV and not dac units.\n",
                         ind);
                 LOG(logERROR, (mess));
-            } else if (checkVLimitCompliant(val) == FAIL) {
-                ret = FAIL;
-                sprintf(mess,
-                        "Could not set power. Power regulator %d "
-                        "exceeds voltage limit %d.\n",
-                        ind, getVLimit());
-                LOG(logERROR, (mess));
+                return retval;
             }
+            ret = setPower(serverDacIndex, val, mess);
+        } else
+            ret = getPower(serverDacIndex, &retval, mess);
+        return retval;
 
-            else if (!isPowerValid(serverDacIndex, val)) {
-                ret = FAIL;
-                sprintf(
-                    mess,
-                    "Could not set power. Power regulator %d "
-                    "should be between %d and %d mV\n",
-                    ind,
-                    (serverDacIndex == D_PWR_IO ? VIO_MIN_MV : POWER_RGLTR_MIN),
-#ifdef CHIPTESTBOARDD
-                    (VCHIP_MAX_MV - VCHIP_POWER_INCRMNT));
-#else
-                    POWER_RGLTR_MAX);
-#endif
-                LOG(logERROR, (mess));
-            }
-
-            else {
-                setPower(serverDacIndex, val);
-            }
-        }
-        if (ret == OK) {
-            retval = getPower(serverDacIndex);
-            LOG(logDEBUG1, ("Power regulator(%d): %d\n", ind, retval));
-            validate(&ret, mess, val, retval, "set power regulator", DEC);
-        }
-        break;
+    // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        if (val != GET_FLAG)
+            ret = setDAC(serverDacIndex, val, mV, mess);
+        else
+            ret = getDAC(serverDacIndex, mV, &retval, mess);
+        return retval;
+    }
+}
 #endif
 
-#ifdef CHIPTESTBOARDD
-    case V_POWER_CHIP:
-        if (val >= 0) {
-            ret = FAIL;
-            sprintf(mess, "Can not set Vchip. Can only be set "
-                          "automatically in the background (+200mV "
-                          "from highest power regulator voltage).\n");
-            LOG(logERROR, (mess));
-            /* restrict users from setting vchip
-            if (!mV) {
-                ret = FAIL;
-                sprintf(mess,"Could not set Vchip. Should be in mV and
-            not dac units.\n"); LOG(logERROR,(mess)); } else if
-            (!isVchipValid(val)) { ret = FAIL; sprintf(mess,"Could not
-            set Vchip. Should be between %d and %d mV\n", VCHIP_MIN_MV,
-            VCHIP_MAX_MV); LOG(logERROR,(mess)); } else { setVchip(val);
-            }
-            */
-        }
-        retval = getVchip();
-        LOG(logDEBUG1, ("Vchip: %d\n", retval));
-        if (ret == OK && val != GET_FLAG && val != -100 && retval != val) {
-            ret = FAIL;
-            sprintf(mess, "Could not set vchip. Set %d, but read %d\n", val,
-                    retval);
-            LOG(logERROR, (mess));
-        }
-        break;
-#endif
+#if XILINX_CHIPTESTBOARDD
+int processDACEnums(enum dacIndex ind, int val, bool mV) {
+    int retval = -1;
+    enum DACINDEX serverDacIndex = 0;
+    switch (ind) {
 
-        // vlimit
-#if defined(CHIPTESTBOARDD) || defined(XILINX_CHIPTESTBOARDD)
     case V_LIMIT:
-        if (val >= 0) {
+        if (val != GET_FLAG) {
             if (!mV) {
                 ret = FAIL;
-                strcpy(mess, "Could not set power. VLimit should be in "
+                strcpy(mess, "Could not set vlimit. VLimit should be in "
                              "mV and not dac units.\n");
                 LOG(logERROR, (mess));
-            } else {
-                setVLimit(val);
+                return retval;
             }
-        }
-        retval = getVLimit();
-        LOG(logDEBUG1, ("VLimit: %d\n", retval));
-        validate(&ret, mess, val, retval, "set vlimit", DEC);
-        break;
-#endif
-        // dacs
-    default:
-        if (mV && val > DAC_MAX_MV) {
-            ret = FAIL;
-            sprintf(mess,
-                    "Could not set dac %d to value %d. Allowed limits "
-                    "(0 - %d mV).\n",
-                    ind, val, DAC_MAX_MV);
-            LOG(logERROR, (mess));
-        } else if (!mV && val > getMaxDacSteps()) {
-            ret = FAIL;
-            sprintf(mess,
-                    "Could not set dac %d to value %d. Allowed limits "
-                    "(0 - %d dac units).\n",
-                    ind, val, getMaxDacSteps());
-            LOG(logERROR, (mess));
-        } else {
-#if defined(CHIPTESTBOARDD) || defined(XILINX_CHIPTESTBOARDD)
-            if ((val != GET_FLAG && mV && checkVLimitCompliant(val) == FAIL) ||
-                (val != GET_FLAG && !mV &&
-                 checkVLimitDacCompliant(val) == FAIL)) {
+            ret = setVLimit(val, mess);
+        } else
+            retval = getVLimit();
+        return retval;
+
+    case V_POWER_A:
+    case V_POWER_B:
+    case V_POWER_C:
+    case V_POWER_D:
+    case V_POWER_IO:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        if (val != GET_FLAG) {
+            if (!mV) {
                 ret = FAIL;
                 sprintf(mess,
-                        "Could not set dac %d to value %d. "
-                        "Exceeds voltage limit %d.\n",
-                        ind, (mV ? val : dacToVoltage(val)), getVLimit());
+                        "Could not set power. Power regulator %d should be in "
+                        "mV and not dac units.\n",
+                        ind);
                 LOG(logERROR, (mess));
-            } else
-#endif
-#ifdef MYTHEN3D
-                // ignore counter enable to force vth dac values
-                setDAC(serverDacIndex, val, mV, 0);
-#else
-            setDAC(serverDacIndex, val, mV);
-#endif
-            retval = getDAC(serverDacIndex, mV);
-        }
-#ifdef EIGERD
-        if (val != GET_FLAG && getSettings() != UNDEFINED) {
-            // changing dac changes settings to undefined
-            switch (serverDacIndex) {
-            case E_VCMP_LL:
-            case E_VCMP_LR:
-            case E_VCMP_RL:
-            case E_VCMP_RR:
-            case E_VRPREAMP:
-            case E_VCP:
-                setSettings(UNDEFINED);
-                LOG(logERROR, ("Settings has been changed "
-                               "to undefined (changed specific dacs)\n"));
-                break;
-            default:
-                break;
+                return retval;
             }
-        }
-#endif
-        // check
-        if (ret == OK) {
-            if ((abs(retval - val) <= 5) || val == GET_FLAG) {
-                ret = OK;
-            } else {
-                ret = FAIL;
-                sprintf(mess, "Setting dac %d : wrote %d but read %d\n",
-                        serverDacIndex, val, retval);
-                LOG(logERROR, (mess));
-            }
-        }
-        LOG(logDEBUG1, ("Dac (%d): %d %s\n\n", serverDacIndex, retval,
-                        (mV ? "mV" : "dac units")));
-#ifdef MYTHEN3D
-        // changed for setsettings (direct),
-        // custom trimbit file (setmodule with myMod.reg as -1),
-        // change of dac (direct)
-        if (val != GET_FLAG && ret == OK) {
-            for (int i = 0; i < NCOUNTERS; ++i) {
-                setThresholdEnergy(i, -1);
-            }
-        }
-#endif
-        break;
+            ret = setPower(serverDacIndex, val, mess);
+        } else
+            ret = getPower(serverDacIndex, &retval, mess);
+        return retval;
+
+    // actual dacs
+    default:
+        serverDacIndex = getDACIndex(ind);
+        if (ret == FAIL)
+            return retval;
+        if (val != GET_FLAG)
+            ret = setDAC(serverDacIndex, val, mV, mess);
+        else
+            ret = getDAC(serverDacIndex, mV, &retval, mess);
+        return retval;
     }
-    return retval;
 }
+#endif
 
 int set_dac(int file_des) {
     ret = OK;
@@ -1463,14 +1484,14 @@ int set_dac(int file_des) {
         return printSocketReadError();
 
     enum dacIndex ind = args[0];
-    int mV = args[1];
+    bool mV = (args[1] != 0);
     int val = args[2];
 
     LOG(logDEBUG1,
         ("Setting DAC %d to %d %s\n", ind, val, (mV ? "mV" : "dac units")));
     // set & get
     if ((val == GET_FLAG) || (Server_VerifyLock() == OK)) {
-        retval = validateAndSetDac(ind, val, mV);
+        retval = processDACEnums(ind, val, mV);
     }
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
@@ -1886,7 +1907,7 @@ int set_settings(int file_des) {
             validate_settings(isett);
 #endif
             if (ret == OK) {
-                setSettings(isett);
+                ret = setSettings(isett, mess);
             }
         }
         retval = getSettings();
@@ -2102,7 +2123,7 @@ void *start_state_machine(void *arg) {
             else {
                 LOG(logINFOBLUE, ("Dac [%d] scan %d/%d: [%d]\n",
                                   scanGlobalIndex, i, times, scanSteps[i]));
-                validateAndSetDac(scanGlobalIndex, scanSteps[i], 0);
+                processDACEnums(scanGlobalIndex, scanSteps[i], false);
                 if (ret == FAIL) {
                     sprintf(scanErrMessage, "Cannot scan dac %d at %d. ",
                             scanGlobalIndex, scanSteps[i]);
@@ -3202,7 +3223,7 @@ int validateAndSetAllTrimbits(int arg) {
 #ifdef EIGERD
             // changes settings to undefined
             if (getSettings() != UNDEFINED) {
-                setSettings(UNDEFINED);
+                setSettings(UNDEFINED, mess);
                 LOG(logERROR,
                     ("Settings has been changed to undefined (change all "
                      "trimbits)\n"));
@@ -6670,30 +6691,7 @@ int set_counter_mask(int file_des) {
 #else
     // only set
     if (Server_VerifyLock() == OK) {
-        if (arg == 0) {
-            ret = FAIL;
-            sprintf(mess, "Could not set counter mask. Cannot set it to 0.\n");
-            LOG(logERROR, (mess));
-        } else if (arg > MAX_COUNTER_MSK) {
-            ret = FAIL;
-            sprintf(mess,
-                    "Could not set counter mask. Invalid counter bit enabled. "
-                    "Max number of counters: %d\n",
-                    NCOUNTERS);
-            LOG(logERROR, (mess));
-        } else {
-            setCounterMask(arg);
-            uint32_t retval = getCounterMask();
-            LOG(logDEBUG, ("counter mask retval: 0x%x\n", retval));
-            if (retval != arg) {
-                ret = FAIL;
-                sprintf(mess,
-                        "Could not set counter mask. Set 0x%x mask, got 0x%x "
-                        "mask\n",
-                        arg, retval);
-                LOG(logERROR, (mess));
-            }
-        }
+        ret = setCounterMask(arg, mess);
     }
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);
@@ -8391,12 +8389,7 @@ int reset_to_default_dacs(int file_des) {
     functionNotImplemented();
 #else
     if (Server_VerifyLock() == OK) {
-        if (resetToDefaultDacs(arg) == FAIL) {
-            ret = FAIL;
-            sprintf(mess, "Could not %s reset default dacs",
-                    (arg == 1 ? "hard" : ""));
-            LOG(logERROR, (mess));
-        }
+        ret = resetToDefaultDacs(arg, mess);
     }
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);
@@ -10163,27 +10156,7 @@ int set_interpolation(int file_des) {
 #else
     // only set
     if (Server_VerifyLock() == OK) {
-        if (getPumpProbe() && arg) {
-            ret = FAIL;
-            sprintf(mess, "Could not set interpolation. Disable pump probe "
-                          "mode first.\n");
-            LOG(logERROR, (mess));
-        } else {
-            ret = setInterpolation(arg);
-            if (ret == FAIL) {
-                if (arg)
-                    sprintf(mess, "Could not set interpolation or enable all "
-                                  "counters for it.\n");
-                else
-                    sprintf(mess, "Could not set interpolation\n");
-                LOG(logERROR, (mess));
-            } else {
-                int retval = getInterpolation();
-                validate(&ret, mess, (int)arg, (int)retval, "set interpolation",
-                         DEC);
-                LOG(logDEBUG1, ("interpolation retval: %u\n", retval));
-            }
-        }
+        ret = setInterpolation((arg != 0), mess);
     }
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);
@@ -10220,23 +10193,7 @@ int set_pump_probe(int file_des) {
 #else
     // only set
     if (Server_VerifyLock() == OK) {
-        if (getInterpolation() && arg) {
-            ret = FAIL;
-            sprintf(mess, "Could not set pump probe mode. Disable "
-                          "interpolation mode first.\n");
-            LOG(logERROR, (mess));
-        } else {
-            ret = setPumpProbe(arg);
-            if (ret == FAIL) {
-                sprintf(mess, "Could not set pump probe\n");
-                LOG(logERROR, (mess));
-            } else {
-                int retval = getPumpProbe();
-                validate(&ret, mess, (int)arg, (int)retval, "set pump probe",
-                         DEC);
-                LOG(logDEBUG1, ("pump probe retval: %u\n", retval));
-            }
-        }
+        ret = setPumpProbe((arg != 0), mess);
     }
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c

@@ -406,22 +406,30 @@ void setupDetector() {
     LTC2620_D_SetDefines(DAC_MIN_MV, DAC_MAX_MV, DAC_DRIVER_FILE_NAME, NDAC,
                          NPWR, DAC_POWERDOWN_DRIVER_FILE_NAME);
 
-    // power LTC2620 before talking to it:
+    // power LTC2620 before talking to it
     initError = XILINX_FMC_enable_all(initErrorMessage, MAX_STR_LENGTH);
     if (initError == FAIL) {
         return;
     }
-
+    // dacs only
     LOG(logINFOBLUE, ("Powering down all dacs\n"));
     for (int idac = 0; idac < NDAC_ONLY; ++idac) {
-        setDAC(idac, LTC2620_D_GetPowerDownValue(), 0);
+        initError = setDAC(idac, LTC2620_D_GetPowerDownValue(), false,
+                           initErrorMessage);
+        if (initError == FAIL)
+            return;
     }
+
+    // power regulators
+    LOG(logINFOBLUE,
+        ("Setting power dacs to min dac value (power disabled)\n"));
     for (int idac = NDAC_ONLY; idac < NDAC; ++idac) {
         if (idac == D_PWR_EMPTY)
             continue;
         int min = (idac == D_PWR_IO) ? VIO_MIN_MV : POWER_RGLTR_MIN;
-        // will not enable power at startup (dacValues = -1)
-        setPower(idac, min);
+        initError = setDAC(idac, min, true, initErrorMessage);
+        if (initError == FAIL)
+            return;
     }
 
     resetFlow();
@@ -1157,204 +1165,321 @@ int64_t getMeasurementTime() {
 }
 
 /* parameters - dac, adc, hv */
-
-void setDAC(enum DACINDEX ind, int val, int mV) {
-    char dacName[MAX_STR_LENGTH] = {0};
-    memset(dacName, 0, MAX_STR_LENGTH);
-    sprintf(dacName, "dac%d", (int)ind);
-
-    if (val < 0 && val != LTC2620_D_GetPowerDownValue())
-        return;
-
-    LOG(logDEBUG1, ("Setting dac[%d - %s]: %d %s \n", (int)ind, dacName, val,
-                    (mV ? "mV" : "dac units")));
-    int dacval = val;
-    if (LTC2620_D_SetDACValue((int)ind, val, mV, dacName, &dacval) == OK)
-        dacValues[ind] = dacval;
-}
-
-int getDAC(enum DACINDEX ind, int mV) {
-    if (!mV) {
-        LOG(logDEBUG1, ("Getting DAC %d : %d dac\n", ind, dacValues[ind]));
-        return dacValues[ind];
-    }
-    int voltage = -1;
-    LTC2620_D_DacToVoltage(dacValues[ind], &voltage);
-    LOG(logDEBUG1,
-        ("Getting DAC %d : %d dac (%d mV)\n", ind, dacValues[ind], voltage));
-    return voltage;
-}
-
-int getMaxDacSteps() { return LTC2620_D_GetMaxNumSteps(); }
-
-int dacToVoltage(int dac) {
-    int val;
-    if (LTC2620_D_DacToVoltage(dac, &val) == FAIL) {
-        return -1;
-    }
-    return val;
-}
-
-int checkVLimitCompliant(int mV) {
-    if (vLimit > 0 && mV > vLimit)
+int validateDACIndex(enum DACINDEX ind, char *mess) {
+    if (ind < 0 || ind >= NDAC) {
+        sprintf(mess, "Could not set DAC. Invalid index %d\n", ind);
+        LOG(logERROR, (mess));
         return FAIL;
+    }
     return OK;
 }
 
-int checkVLimitDacCompliant(int dac) {
-    if (vLimit > 0 && dac != -1 && dac != LTC2620_D_GetPowerDownValue()) {
-        int mv = 0;
-        // could not convert
-        if (LTC2620_D_DacToVoltage(dac, &mv) == FAIL)
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess) {
+    // validate min value
+    if (voltage < 0) {
+        sprintf(mess,
+                "Could not set DAC %d. Input value %d cannot be negative\n",
+                ind, voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (voltage > DAC_MAX_MV) {
+        sprintf(
+            mess,
+            "Could not set DAC %d. Input value %d mV exceeds maximum %d mV\n",
+            ind, voltage, DAC_MAX_MV);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate vlimit
+    if (vLimit > 0 && voltage > vLimit) {
+        sprintf(mess,
+                "Could not set DAC %d. Input %d mV exceeds vLimit %d mV\n", ind,
+                voltage, vLimit);
+        LOG(logERROR, (mess))
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess) {
+    *retval_dacval = -1;
+    // normal dacs
+    if (ind < NDAC_ONLY) {
+        if (LTC2620_D_VoltageToDac(voltage, retval_dacval) == FAIL) {
+            sprintf(
+                mess,
+                "Could not set DAC %d. Could not convert %d mV to dac units.\n",
+                ind, voltage);
+            LOG(logERROR, (mess));
             return FAIL;
-        if (mv > vLimit)
+        }
+        return OK;
+    }
+    // power dacs
+    if (ConvertToDifferentRange(
+            POWER_RGLTR_MIN, POWER_RGLTR_MAX, LTC2620_D_GetMaxInput(),
+            LTC2620_D_GetMinInput(), voltage, retval_dacval) == FAIL) {
+        sprintf(mess,
+                "Could not set DAC %d. Could not convert %d mV to dac units.\n",
+                ind, voltage);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess) {
+    *retval_voltage = -1;
+    // normal dacs
+    if (ind < NDAC_ONLY) {
+        if (LTC2620_D_DacToVoltage(dacval, retval_voltage) == FAIL) {
+            sprintf(
+                mess,
+                "Could not get DAC %d. Could not convert %d dac units to mV\n",
+                ind, dacval);
+            LOG(logERROR, (mess));
+            return FAIL;
+        }
+        return OK;
+    }
+    // power dacs
+    if (ConvertToDifferentRange(
+            LTC2620_D_GetMaxInput(), LTC2620_D_GetMinInput(), POWER_RGLTR_MIN,
+            POWER_RGLTR_MAX, dacval, retval_voltage) == FAIL) {
+        sprintf(mess,
+                "Could not get DAC %d. Could not convert %d dac units to mV\n",
+                ind, dacval);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess) {
+    *retval = -1;
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = dacValues[ind];
+    if (dacval == LTC2620_D_GetPowerDownValue()) {
+        LOG(logWARNING, ("DAC %d is in power down mode.\n", ind));
+        *retval = dacval;
+        return OK;
+    }
+
+    if (mV) {
+        if (convertDACValueToVoltage(ind, dacval, retval, mess) == FAIL)
+            return FAIL;
+        return OK;
+    }
+
+    *retval = dacval;
+    return OK;
+}
+
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess) {
+    LOG(logINFO,
+        ("Setting DAC %d: %d %s \n", ind, val, (mV ? "mV" : "dac units")));
+    if (validateDACIndex(ind, mess) == FAIL)
+        return FAIL;
+
+    int dacval = val;
+    if (mV) {
+        if (ind < NDAC_ONLY) {
+            if (validateDACVoltage(ind, val, mess) == FAIL)
+                return FAIL;
+        }
+        if (convertVoltageToDACValue(ind, val, &dacval, mess) == FAIL)
             return FAIL;
     }
+    {
+        char dacName[20] = {0};
+        snprintf(dacName, sizeof(dacName), "dac %d", ind);
+        if (LTC2620_D_SetDacValue((int)ind, dacval, dacName, mess) == FAIL)
+            return FAIL;
+    }
+    dacValues[ind] = dacval;
     return OK;
 }
 
 int getVLimit() { return vLimit; }
 
-void setVLimit(int l) {
-    if (l >= 0)
-        vLimit = l;
+int setVLimit(int val, char *mess) {
+    if (val < 0) {
+        sprintf(mess, "Could not set vlimit. Invalid value %d\n", val);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    vLimit = val;
+    return OK;
 }
 
-int getBitOffsetFromDACIndex(enum DACINDEX ind) {
+int validatePower(enum PWRINDEX ind, int val, char *mess) {
+    char *powerNames[] = {PWR_NAMES};
+    // validate min value
+    int min = (ind == PWR_IO) ? VIO_MIN_MV : POWER_RGLTR_MIN;
+    if (val < min && val != 0) {
+        sprintf(
+            mess,
+            "Could not set %s. Input value %d mV must be greater than %d mV.\n",
+            powerNames[ind], val, min);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate max value
+    if (val > POWER_RGLTR_MAX) {
+        sprintf(
+            mess,
+            "Could not set %s. Input value %d mV must be less than %d mV.\n",
+            powerNames[ind], val, POWER_RGLTR_MAX);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    // validate vlimit
+    if (vLimit > 0 && val > vLimit) {
+        sprintf(mess, "Could not set %s. Input %d mV exceeds vLimit %d mV\n",
+                powerNames[ind], val, vLimit);
+        LOG(logERROR, (mess))
+        return FAIL;
+    }
+    return OK;
+}
+
+// for power rail index and name debugging
+int getPowerIndexFromDACIndex(enum DACINDEX ind, enum PWRINDEX *pwrIndex,
+                              char *mess) {
+    *pwrIndex = PWR_IO;
     switch (ind) {
     case D_PWR_IO:
-        return POWER_VIO_OFST;
+        *pwrIndex = PWR_IO;
+        break;
     case D_PWR_A:
-        return POWER_VCC_A_OFST;
+        *pwrIndex = PWR_A;
+        break;
     case D_PWR_B:
-        return POWER_VCC_B_OFST;
+        *pwrIndex = PWR_B;
+        break;
     case D_PWR_C:
-        return POWER_VCC_C_OFST;
+        *pwrIndex = PWR_C;
+        break;
     case D_PWR_D:
-        return POWER_VCC_D_OFST;
+        *pwrIndex = PWR_D;
+        break;
     default:
-        LOG(logERROR,
-            ("DAC index %d is not defined to get offset in ctrl register\n",
-             ind));
-        return -1;
+        sprintf(mess, "Index %d has no power index\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
     }
+    return OK;
 }
 
-int isPowerValid(enum DACINDEX ind, int val) {
+int getPowerRailMask(enum PWRINDEX ind, uint32_t *mask, char *mess) {
+    *mask = 0;
+    switch (ind) {
+    case PWR_IO:
+        *mask = POWER_VIO_MSK;
+        break;
+    case PWR_A:
+        *mask = POWER_VCC_A_MSK;
+        break;
+    case PWR_B:
+        *mask = POWER_VCC_B_MSK;
+        break;
+    case PWR_C:
+        *mask = POWER_VCC_C_MSK;
+        break;
+    case PWR_D:
+        *mask = POWER_VCC_D_MSK;
+        break;
+    default:
+        sprintf(mess, "Index %d has no power rail index\n", ind);
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+    return OK;
+}
+
+int EnablePowerRail(enum PWRINDEX ind, char *mess) {
     char *powerNames[] = {PWR_NAMES};
-    int pwrIndex = (int)(ind - D_PWR_D);
-
-    int min = POWER_RGLTR_MIN;
-    if (!strcmp(powerNames[pwrIndex], "IO")) {
-        min = VIO_MIN_MV;
-    }
-
-    // not power_rgltr_max because it is allowed only upto vchip max - 200
-    if (val != 0 && (val != LTC2620_D_GetPowerDownValue()) &&
-        (val < min || val > POWER_RGLTR_MAX)) {
-        LOG(logERROR,
-            ("Invalid value of %d mV for Power V%s. Is not between %d and "
-             "%d mV\n",
-             val, powerNames[pwrIndex], min, POWER_RGLTR_MAX));
-        return 0;
-    }
-    return 1;
-}
-
-int getPower(enum DACINDEX ind) {
-    // get bit offset in ctrl register
-    int bitOffset = getBitOffsetFromDACIndex(ind);
-    if (bitOffset == -1) {
-        return -1;
-    }
-
-    // powered enable off
-    {
-        uint32_t addr = CTRL_REG;
-        uint32_t mask = (1 << bitOffset);
-        if (!(bus_r(addr) & mask))
-            return 0;
-    }
-
-    char *powerNames[] = {PWR_NAMES};
-    int pwrIndex = (int)(ind - D_PWR_D);
-
-    // not set yet
-    if (dacValues[ind] == -1) {
-        LOG(logERROR,
-            ("Unknown dac value for Power V%s!\n", powerNames[pwrIndex]));
-        return -1;
-    }
-
-    // dac powered off
-    if (dacValues[ind] == LTC2620_D_GetPowerDownValue()) {
-        LOG(logWARNING, ("Power V%s enabled, but voltage is at minimum or 0.\n",
-                         powerNames[pwrIndex]));
-        return LTC2620_D_GetPowerDownValue();
-    }
-
-    // get dac in mV
-    int retval = -1;
-    ConvertToDifferentRange(LTC2620_D_GetMaxInput(), LTC2620_D_GetMinInput(),
-                            POWER_RGLTR_MIN, POWER_RGLTR_MAX, dacValues[ind],
-                            &retval);
-
-    return retval;
-}
-
-void setPower(enum DACINDEX ind, int val) {
-    if (val < 0)
-        return;
-
-    // validate index and get bit offset in ctrl register
-    int bitOffset = getBitOffsetFromDACIndex(ind);
-    if (bitOffset == -1) {
-        return;
-    }
     uint32_t addr = CTRL_REG;
-    uint32_t mask = (1 << bitOffset);
+    uint32_t mask = 0;
+
+    if (getPowerRailMask(ind, &mask, mess) == FAIL)
+        return FAIL;
+
+    LOG(logINFO, ("\tSwitching on power for %s\n", powerNames[ind]));
+    bus_w(addr, bus_r(addr) | mask);
+    return OK;
+}
+
+int DisablePowerRail(enum PWRINDEX ind, char *mess) {
     char *powerNames[] = {PWR_NAMES};
-    int pwrIndex = (int)(ind - D_PWR_D);
-    LOG(logINFO, ("Setting Power V%s to %d mV\n", powerNames[pwrIndex], val));
+    uint32_t addr = CTRL_REG;
+    uint32_t mask = 0;
 
-    // validate value (already checked at tcp (funcs.c))
-    if (!isPowerValid(ind, val)) {
-        LOG(logERROR, ("Invalid power value for V%s: %d mV\n",
-                       powerNames[pwrIndex], val));
-        return;
-    }
+    if (getPowerRailMask(ind, &mask, mess) == FAIL)
+        return FAIL;
 
-    // Switch off power enable
-    LOG(logDEBUG1, ("Switching off power enable\n"));
+    LOG(logINFO, ("\tSwitching off power for %s\n", powerNames[ind]));
     bus_w(addr, bus_r(addr) & ~(mask));
+    return OK;
+}
 
-    int startup = dacValues[ind] == -1 ? 1 : 0;
+int getPowerRail(enum PWRINDEX ind, int *retval, char *mess) {
+    char *powerNames[] = {PWR_NAMES};
+    uint32_t addr = CTRL_REG;
+    uint32_t mask = 0;
 
-    // convert voltage to dac (power off is anyway done with power enable)
-    if (val > 0) {
+    if (getPowerRailMask(ind, &mask, mess) == FAIL)
+        return FAIL;
 
-        int dacval = -1;
-        if (ConvertToDifferentRange(
-                POWER_RGLTR_MIN, POWER_RGLTR_MAX, LTC2620_D_GetMaxInput(),
-                LTC2620_D_GetMinInput(), val, &dacval) == FAIL) {
-            LOG(logERROR,
-                ("\tCannot convert Power V%s to dac value. Invalid value of %d "
-                 "mV.n",
-                 powerNames[pwrIndex], val));
-            return;
-        }
+    *retval = (bus_r(addr) & mask);
+    LOG(logDEBUG1, ("Power rail retval for %s: %s\n", powerNames[ind],
+                    ((*retval > 0) ? "Enabled" : "Disabled")));
 
-        // set and power on/ update dac
-        LOG(logINFO, ("Setting Power V%s: %d mV (%d dac)\n",
-                      powerNames[pwrIndex], val, dacval));
-        setDAC(ind, dacval, 0);
+    return OK;
+}
 
-        // if valid, enable power
-        if (dacval >= 0 && startup == 0) {
-            LOG(logDEBUG1, ("Switching on power enable\n"));
-            bus_w(addr, bus_r(addr) | mask);
-        }
+int getPower(enum DACINDEX ind, int *retval, char *mess) {
+    enum PWRINDEX pwrIndex = PWR_IO;
+    if (getPowerIndexFromDACIndex(ind, &pwrIndex, mess) == FAIL)
+        return FAIL;
+
+    // if powered off, return 0
+    if (getPowerRail(pwrIndex, retval, mess) == FAIL)
+        return FAIL;
+    if (*retval == 0) {
+        return OK;
     }
+
+    if (getDAC(ind, true, retval, mess) == FAIL)
+        return FAIL;
+    return OK;
+}
+
+int setPower(enum DACINDEX ind, int val, char *mess) {
+    enum PWRINDEX pwrIndex = PWR_IO;
+    if (getPowerIndexFromDACIndex(ind, &pwrIndex, mess) == FAIL)
+        return FAIL;
+
+    char *powerNames[] = {PWR_NAMES};
+    LOG(logINFOBLUE, ("Setting %s to %d mV\n", powerNames[pwrIndex], val));
+
+    if (validatePower(pwrIndex, val, mess) == FAIL)
+        return FAIL;
+    if (DisablePowerRail(pwrIndex, mess) == FAIL)
+        return FAIL;
+    if (val != 0) {
+        if (setDAC(ind, val, true, mess) == FAIL)
+            return FAIL;
+        if (EnablePowerRail(pwrIndex, mess) == FAIL)
+            return FAIL;
+    }
+    return OK;
 }
 
 int getADC(enum ADCINDEX ind, int *value) {

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.h

@@ -6,6 +6,7 @@
 #include "arm64.h"
 #include "programViaArm.h"
 
+#include <stdbool.h>
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -119,18 +120,29 @@ int64_t getMeasurementTime();
 int setModule(sls_detector_module myMod, char *mess);
 
 // parameters - dac, adc, hv
-void setDAC(enum DACINDEX ind, int val, int mV);
-int getDAC(enum DACINDEX ind, int mV);
-int getMaxDacSteps();
-int dacToVoltage(int dac);
-int checkVLimitCompliant(int mV);
-int checkVLimitDacCompliant(int dac);
+int validateDACIndex(enum DACINDEX ind, char *mess);
+int validateDACVoltage(enum DACINDEX ind, int voltage, char *mess);
+int convertVoltageToDACValue(enum DACINDEX ind, int voltage, int *retval_dacval,
+                             char *mess);
+int convertDACValueToVoltage(enum DACINDEX ind, int dacval, int *retval_voltage,
+                             char *mess);
+int getDAC(enum DACINDEX ind, bool mV, int *retval, char *mess);
+/** @param val value can be in mV or dac units */
+int setDAC(enum DACINDEX ind, int val, bool mV, char *mess);
+
 int getVLimit();
-void setVLimit(int l);
-int getBitOffsetFromDACIndex(enum DACINDEX ind);
-int isPowerValid(enum DACINDEX ind, int val);
-int getPower();
-void setPower(enum DACINDEX ind, int val);
+int setVLimit(int val, char *mess);
+
+int validatePower(enum PWRINDEX ind, int val, char *mess);
+int getPowerIndexFromDACIndex(enum DACINDEX ind, enum PWRINDEX *pwrIndex,
+                              char *mess);
+int getPowerRailMask(enum PWRINDEX ind, uint32_t *mask, char *mess);
+int EnablePowerRail(enum PWRINDEX ind, char *mess);
+int DisablePowerRail(enum PWRINDEX ind, char *mess);
+int getPowerRail(enum PWRINDEX ind, int *retval, char *mess);
+int getPower(enum DACINDEX ind, int *retval, char *mess);
+int setPower(enum DACINDEX ind, int val, char *mess);
+
 int getADC(enum ADCINDEX ind, int *value);
 int getSlowADC(int ichan, int *retval);
 int getTemperature(int *retval);

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorServer_defs.h

@@ -119,7 +119,8 @@ enum DACINDEX {
     D_PWR_C
 };
 
-#define PWR_NAMES "D", "_unknown", "IO", "A", "B", "C"
+enum PWRINDEX { PWR_IO, PWR_A, PWR_B, PWR_C, PWR_D };
+#define PWR_NAMES "VIO", "VA", "VB", "VC", "VD"
 
 /* Struct Definitions */
 // For arm has to be multiple of 16

slsDetectorSoftware/src/Module.cpp

@@ -803,6 +803,10 @@ void Module::resetToDefaultDacs(const bool hardReset) {
 }
 
 void Module::setDAC(int val, dacIndex index, bool mV) {
+    // -1 reserved for get at the moment (get_dac also calls F_SET_DAC)
+    if (val == -1) {
+        throw RuntimeError("Invalid input. DAC value cannot be set to -1.");
+    }
     int args[]{static_cast<int>(index), static_cast<int>(mV), val};
     sendToDetector<int>(F_SET_DAC, args);
 }

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

@@ -501,6 +501,29 @@ TEST_CASE("dac", "[.detectorintegration][.dacs]") {
                 test_dac_caller(static_cast<defs::dacIndex>(i), "dac", 0);
             }
         }
+        // normal dacs
+        {
+            defs::dacIndex idac = defs::DAC_5;
+            auto previous = det.getDAC(idac, false);
+
+            REQUIRE_THROWS(
+                caller.call("dac", {std::to_string(idac), "-2"}, -1, PUT));
+            REQUIRE_THROWS(
+                caller.call("dac", {std::to_string(idac), "-1"}, -1, PUT));
+            REQUIRE_NOTHROW(
+                caller.call("dac", {std::to_string(idac), "-100"}, -1, PUT));
+
+            // Reset all dacs to previous value
+            for (int i = 0; i != det.size(); ++i) {
+                det.setDAC(idac, previous[i], false, {i});
+            }
+        }
+        REQUIRE_THROWS(caller.call("dac", {"18"}, -1, GET));
+        REQUIRE_THROWS(caller.call("dac", {"5", "4096"}, -1, PUT));
+        if (det_type == defs::CHIPTESTBOARD)
+            REQUIRE_THROWS(caller.call("dac", {"5", "2501", "mV"}, -1, PUT));
+        else
+            REQUIRE_THROWS(caller.call("dac", {"5", "2049", "mV"}, -1, PUT));
 
         // eiger
         // REQUIRE_THROWS(caller.call("dac", {"vthreshold"}, -1, GET));
@@ -1054,6 +1077,25 @@ TEST_CASE("v_abcd", "[.detectorintegration]") {
                 REQUIRE(prev_val.any(-100) == false);
                 REQUIRE(prev_val.any(-1) == false);
             }
+            REQUIRE_THROWS(caller.call(cmds[i], {"-2"}, -1, PUT));
+            REQUIRE_THROWS(caller.call(cmds[i], {"-100"}, -1, PUT));
+            REQUIRE_THROWS(caller.call(cmds[i], {"-1"}, -1, PUT));
+            if (cmds[i] == "v_io")
+                REQUIRE_THROWS(caller.call(cmds[i], {"1199"}, -1, PUT)); // min
+            else {
+                if (det_type == defs::XILINX_CHIPTESTBOARD) {
+                    REQUIRE_THROWS(
+                        caller.call(cmds[i], {"1040"}, -1, PUT)); // min v_a
+                } else {
+                    REQUIRE_THROWS(
+                        caller.call(cmds[i], {"635"}, -1, PUT)); // min v_a
+                }
+            }
+            if (det_type == defs::XILINX_CHIPTESTBOARD) {
+                REQUIRE_THROWS(caller.call(cmds[i], {"2662"}, -1, PUT)); // max
+            } else {
+                REQUIRE_THROWS(caller.call(cmds[i], {"2469"}, -1, PUT)); // max
+            }
             {
                 std::ostringstream oss;
                 caller.call(cmds[i], {"0"}, -1, PUT, oss);

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

@@ -1009,7 +1009,7 @@ Document parse_binary_master_attributes(std::string file_path) {
 
     Document doc;
     ParseResult result = doc.Parse(json_str.c_str());
-    if (result == 0) {
+    if (!result) {
         std::cout << "JSON parse error: " << GetParseError_En(result.Code())
                   << " (at offset " << result.Offset() << ")" << std::endl;
 
@@ -1019,7 +1019,7 @@ Document parse_binary_master_attributes(std::string file_path) {
             json_str.substr(std::max(0, (int)offset - 20), 40);
         std::cout << "Context around error: \"" << context << "\"" << std::endl;
     }
-    REQUIRE(result != 0);
+    REQUIRE(result);
     return doc;
 }
 

slsSupportLib/include/sls/versionAPI.h

@@ -3,10 +3,10 @@
 /** API versions */
 #define APILIB       "0.0.0 0x250909"
 #define APIRECEIVER  "0.0.0 0x250822"
-#define APICTB       "0.0.0 0x250922"
-#define APIGOTTHARD2 "0.0.0 0x250909"
-#define APIMOENCH    "0.0.0 0x250909"
-#define APIEIGER     "0.0.0 0x250909"
-#define APIXILINXCTB "0.0.0 0x260128"
-#define APIJUNGFRAU  "0.0.0 0x250909"
-#define APIMYTHEN3   "0.0.0 0x250922"
+#define APICTB       "0.0.0 0x260219"
+#define APIGOTTHARD2 "0.0.0 0x260218"
+#define APIMOENCH    "0.0.0 0x260218"
+#define APIEIGER     "0.0.0 0x260218"
+#define APIXILINXCTB "0.0.0 0x260218"
+#define APIJUNGFRAU  "0.0.0 0x260218"
+#define APIMYTHEN3   "0.0.0 0x260219"

tests/scripts/utils_for_test.py

@@ -200,7 +200,7 @@ def runProcess(name, cmd, fp, log_file_name = None, quiet_mode=False):
     Log(LogLevel.INFOBLUE, info_text, fp, True)
     Log(LogLevel.INFOBLUE, 'Cmd: ' + ' '.join(cmd), fp, True)
 
-    error_log = None
+    captured_log = []
 
     try:
         if log_file_name:
@@ -212,8 +212,8 @@ def runProcess(name, cmd, fp, log_file_name = None, quiet_mode=False):
 
     except subprocess.CalledProcessError as e:
         print("error: ", str(e))
-        captured_log = e.stdout.splitlines()
-        pass
+        if not log_file_name and e.stdout:
+            captured_log = e.stdout.splitlines()
     except Exception as e:
         print("something else failed")
         Log(LogLevel.ERROR, f'Failed to run {name}:{str(e)}', fp)