diff --git a/slsDetectorServers/ctbDetectorServer/RegisterDefs.h b/slsDetectorServers/ctbDetectorServer/RegisterDefs.h index ebae6819f..b54d32ae1 100644 --- a/slsDetectorServers/ctbDetectorServer/RegisterDefs.h +++ b/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) diff --git a/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer b/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer index e1b0fb940..2bcda6f53 100755 Binary files a/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer and b/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer differ diff --git a/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c index e7f914ca1..1685b94fa 100644 --- a/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c +++ b/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 */ diff --git a/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.h index 369e71119..7b2a30716 100644 --- a/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.h +++ b/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.h @@ -7,6 +7,7 @@ #include "blackfin.h" #include "programViaBlackfin.h" +#include #include // FILE #include #include @@ -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 diff --git a/slsDetectorServers/ctbDetectorServer/slsDetectorServer_defs.h b/slsDetectorServers/ctbDetectorServer/slsDetectorServer_defs.h index ab899fdb9..c524089c1 100644 --- a/slsDetectorServers/ctbDetectorServer/slsDetectorServer_defs.h +++ b/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" diff --git a/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer b/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer index 19a7c189b..8890ca0bc 100755 Binary files a/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer and b/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer differ diff --git a/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c index f2290afbe..b1896607f 100644 --- a/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c +++ b/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")); diff --git a/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.h index 426c8fd7f..1907f03be 100644 --- a/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.h +++ b/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 #include // FILE #include #include @@ -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); diff --git a/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer b/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer index 2732f13a7..d45912b79 100755 Binary files a/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer and b/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer differ diff --git a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c index 199e26fab..15af49ac2 100644 --- a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c +++ b/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)); diff --git a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.h index 598a4e251..4f84a1307 100644 --- a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.h +++ b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.h @@ -6,6 +6,7 @@ #include "nios.h" #include "programViaNios.h" +#include #include // FILE #include #include @@ -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); diff --git a/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer b/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer index a992aa229..56fbc590f 100755 Binary files a/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer and b/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer differ diff --git a/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c index 9ddc04c89..8d0d1379f 100644 --- a/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c +++ b/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 */ diff --git a/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.h index 951098e2b..b775ff0e1 100644 --- a/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.h +++ b/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.h @@ -7,6 +7,7 @@ #include "blackfin.h" #include "programViaBlackfin.h" +#include #include // FILE #include #include @@ -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); diff --git a/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer b/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer index 4b49971ca..1d3665c96 100755 Binary files a/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer and b/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer differ diff --git a/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c index bebb87f8f..509c92a15 100644 --- a/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c +++ b/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 */ diff --git a/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.h index 8ab13a49b..ef68e5685 100644 --- a/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.h +++ b/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.h @@ -7,6 +7,7 @@ #include "blackfin.h" #include "programViaBlackfin.h" +#include #include // FILE #include #include @@ -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); diff --git a/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer b/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer index e4f56bed2..2149b2a6c 100755 Binary files a/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer and b/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer differ diff --git a/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c index 0d0b6570c..8c7f107aa 100644 --- a/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c +++ b/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) { diff --git a/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.h index 1032fcc32..09f49d589 100644 --- a/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.h +++ b/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.h @@ -7,6 +7,7 @@ #include "nios.h" #include "programViaNios.h" +#include #include // FILE #include #include @@ -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); diff --git a/slsDetectorServers/slsDetectorServer/include/AD9257.h b/slsDetectorServers/slsDetectorServer/include/AD9257.h index d0d282c92..c7e643fb1 100644 --- a/slsDetectorServers/slsDetectorServer/include/AD9257.h +++ b/slsDetectorServers/slsDetectorServer/include/AD9257.h @@ -3,6 +3,7 @@ #pragma once #include +#include #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 diff --git a/slsDetectorServers/slsDetectorServer/include/DAC6571.h b/slsDetectorServers/slsDetectorServer/include/DAC6571.h index 3a86ea900..c5e6a83d8 100644 --- a/slsDetectorServers/slsDetectorServer/include/DAC6571.h +++ b/slsDetectorServers/slsDetectorServer/include/DAC6571.h @@ -5,5 +5,5 @@ #include 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); diff --git a/slsDetectorServers/slsDetectorServer/include/LTC2620.h b/slsDetectorServers/slsDetectorServer/include/LTC2620.h index b9841f615..24262fced 100644 --- a/slsDetectorServers/slsDetectorServer/include/LTC2620.h +++ b/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); \ No newline at end of file +/** From */ +int LTC2620_SetDacValue(int dacnum, int val, char *dacname, char *mess); \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer/include/LTC2620_Driver.h b/slsDetectorServers/slsDetectorServer/include/LTC2620_Driver.h index f11139ac2..c63c332e7 100644 --- a/slsDetectorServers/slsDetectorServer/include/LTC2620_Driver.h +++ b/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); \ No newline at end of file +int LTC2620_D_SetDacValue(int dacnum, int val, char *dacname, char *mess); \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer/include/MAX1932.h b/slsDetectorServers/slsDetectorServer/include/MAX1932.h index e19e0c8da..06d863cc1 100644 --- a/slsDetectorServers/slsDetectorServer/include/MAX1932.h +++ b/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); diff --git a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h index e43148b83..493b1638f 100644 --- a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h +++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h @@ -4,6 +4,7 @@ #include "clogger.h" #include "common.h" #include "sls/sls_detector_defs.h" +#include #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); diff --git a/slsDetectorServers/slsDetectorServer/src/AD9257.c b/slsDetectorServers/slsDetectorServer/src/AD9257.c index 568d2f8d8..5472b6152 100644 --- a/slsDetectorServers/slsDetectorServer/src/AD9257.c +++ b/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) { diff --git a/slsDetectorServers/slsDetectorServer/src/DAC6571.c b/slsDetectorServers/slsDetectorServer/src/DAC6571.c index d9770043a..20308af27 100644 --- a/slsDetectorServers/slsDetectorServer/src/DAC6571.c +++ b/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 diff --git a/slsDetectorServers/slsDetectorServer/src/LTC2620.c b/slsDetectorServers/slsDetectorServer/src/LTC2620.c index ab28d4c8a..2a62fa982 100644 --- a/slsDetectorServers/slsDetectorServer/src/LTC2620.c +++ b/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; } diff --git a/slsDetectorServers/slsDetectorServer/src/LTC2620_Driver.c b/slsDetectorServers/slsDetectorServer/src/LTC2620_Driver.c index c92c111f4..e08a98caf 100644 --- a/slsDetectorServers/slsDetectorServer/src/LTC2620_Driver.c +++ b/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 } diff --git a/slsDetectorServers/slsDetectorServer/src/MAX1932.c b/slsDetectorServers/slsDetectorServer/src/MAX1932.c index 2edf69f27..32829a1b8 100644 --- a/slsDetectorServers/slsDetectorServer/src/MAX1932.c +++ b/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; diff --git a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c index af0f205ea..fa13d9d7a 100644 --- a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c +++ b/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); diff --git a/slsDetectorServers/xilinx_ctbDetectorServer/bin/xilinx_ctbDetectorServer_developer b/slsDetectorServers/xilinx_ctbDetectorServer/bin/xilinx_ctbDetectorServer_developer index 614960290..074697017 100755 Binary files a/slsDetectorServers/xilinx_ctbDetectorServer/bin/xilinx_ctbDetectorServer_developer and b/slsDetectorServers/xilinx_ctbDetectorServer/bin/xilinx_ctbDetectorServer_developer differ diff --git a/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c index 4c98ea216..9b30ab682 100644 --- a/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c +++ b/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) { diff --git a/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.h b/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.h index 8d76bf57b..64766d63e 100644 --- a/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.h +++ b/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.h @@ -6,6 +6,7 @@ #include "arm64.h" #include "programViaArm.h" +#include #include // FILE #include #include @@ -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); diff --git a/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorServer_defs.h b/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorServer_defs.h index 0ac8e1d5d..ef1cef945 100644 --- a/slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorServer_defs.h +++ b/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 diff --git a/slsDetectorSoftware/src/Module.cpp b/slsDetectorSoftware/src/Module.cpp index 8a97afb89..29a51f5b4 100644 --- a/slsDetectorSoftware/src/Module.cpp +++ b/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(index), static_cast(mV), val}; sendToDetector(F_SET_DAC, args); } diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp index ca6e4aa85..04734111d 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp @@ -501,6 +501,29 @@ TEST_CASE("dac", "[.detectorintegration][.dacs]") { test_dac_caller(static_cast(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); diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp index e2ef3c9d0..4d0e0a6f5 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp +++ b/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; } diff --git a/slsSupportLib/include/sls/versionAPI.h b/slsSupportLib/include/sls/versionAPI.h index 245acb823..ad186cee8 100644 --- a/slsSupportLib/include/sls/versionAPI.h +++ b/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" diff --git a/tests/scripts/utils_for_test.py b/tests/scripts/utils_for_test.py index 66c43fb38..9e1b527ee 100644 --- a/tests/scripts/utils_for_test.py +++ b/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)