diff --git a/slsDetectorGui/forms/form_tab_measurement.ui b/slsDetectorGui/forms/form_tab_measurement.ui index 10fdfc038..263ae3562 100755 --- a/slsDetectorGui/forms/form_tab_measurement.ui +++ b/slsDetectorGui/forms/form_tab_measurement.ui @@ -432,19 +432,6 @@ 4 - - - - false - - - <html><head/><body><p>Number of Triggers to be expected.</p><p> #triggers#</p></body></html> - - - Number of Triggers: - - - @@ -666,108 +653,6 @@ Frame period between exposures. - - - - false - - - The Delay between Trigger Edge and Start of Exposure ( or Readout). -#delay# - - - Delay After Trigger: - - - - - - - false - - - - 0 - 0 - - - - - 0 - 25 - - - - Number of Triggers to be expected. - #triggers# - - - - - - - - - Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter - - - false - - - - - - -1 - - - 2000000000 - - - 1 - - - - - - - false - - - - 0 - 0 - - - - - 0 - 25 - - - - The Delay between Trigger Edge and Start of Exposure ( or Readout). -#delay# - - - Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter - - - false - - - 9 - - - -1.000000000000000 - - - 2000000000.000000000000000 - - - 0.000000000000000 - - - @@ -903,65 +788,6 @@ Exposure Time of a frame. - - - - false - - - - 0 - 0 - - - - - 0 - 25 - - - - The Delay between Trigger Edge and Start of Exposure ( or Readout). -#delay# - - - Qt::LeftToRight - - - 2 - - - - hr - - - - - min - - - - - s - - - - - ms - - - - - us - - - - - ns - - - - @@ -1084,6 +910,577 @@ Frame period between exposures. + + + + + 0 + 0 + + + + + 171 + 32 + + + + + 171 + 32 + + + + 0 + + + + + 0 + + + 0 + + + + + false + + + <html><head/><body><p>Number of Triggers to be expected.</p><p> #triggers#</p></body></html> + + + Number of Triggers: + + + + + + + + + 0 + + + 0 + + + + + false + + + <html><head/><body><p>Number of Triggers to be expected.</p><p> #triggers#</p></body></html> + + + Number of Bursts: + + + + + + + + + + + + 0 + 0 + + + + + 208 + 32 + + + + + 208 + 32 + + + + 0 + + + + + 0 + + + 0 + + + + + false + + + + 0 + 0 + + + + + 0 + 25 + + + + Number of Triggers to be expected. + #triggers# + + + + + + + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + + + false + + + + + + -1 + + + 2000000000 + + + 1 + + + + + + + + + 0 + + + 0 + + + + + false + + + + 0 + 0 + + + + + 0 + 25 + + + + Number of Triggers to be expected. + #triggers# + + + + + + + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + + + false + + + + + + -1 + + + 2000000000 + + + 1 + + + + + + + + + + + + 0 + 0 + + + + + 171 + 32 + + + + + 171 + 32 + + + + 0 + + + + + 0 + + + 0 + + + + + false + + + <html><head/><body><p>Number of Triggers to be expected.</p><p> #triggers#</p></body></html> + + + Delay After Trigger: + + + + + + + + + 0 + + + 0 + + + + + false + + + <html><head/><body><p>Number of Triggers to be expected.</p><p> #triggers#</p></body></html> + + + Burst Period: + + + + + + + + + + + + 0 + 0 + + + + + 152 + 32 + + + + + 152 + 32 + + + + 0 + + + + + 0 + + + 0 + + + + + false + + + + 0 + 0 + + + + + 0 + 25 + + + + The Delay between Trigger Edge and Start of Exposure ( or Readout). +#delay# + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + + + false + + + 9 + + + -1.000000000000000 + + + 2000000000.000000000000000 + + + 0.000000000000000 + + + + + + + + + 0 + + + 0 + + + + + false + + + + 0 + 0 + + + + + 0 + 25 + + + + The Delay between Trigger Edge and Start of Exposure ( or Readout). +#delay# + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + + + false + + + 9 + + + -1.000000000000000 + + + 2000000000.000000000000000 + + + 0.000000000000000 + + + + + + + + + + + + 0 + 0 + + + + + 50 + 32 + + + + + 50 + 32 + + + + 0 + + + + + 0 + + + 0 + + + + + false + + + + 0 + 0 + + + + + 0 + 25 + + + + The Delay between Trigger Edge and Start of Exposure ( or Readout). +#delay# + + + Qt::LeftToRight + + + 2 + + + + hr + + + + + min + + + + + s + + + + + ms + + + + + us + + + + + ns + + + + + + + + + + 0 + + + 0 + + + + + false + + + + 0 + 0 + + + + + 0 + 25 + + + + The Delay between Trigger Edge and Start of Exposure ( or Readout). +#delay# + + + Qt::LeftToRight + + + 2 + + + + hr + + + + + min + + + + + s + + + + + ms + + + + + us + + + + + ns + + + + + + + + @@ -1116,9 +1513,6 @@ Frame period between exposures. comboExpUnit spinPeriod comboPeriodUnit - spinNumTriggers - spinDelay - comboDelayUnit spinNumSamples diff --git a/slsDetectorGui/include/qTabMeasurement.h b/slsDetectorGui/include/qTabMeasurement.h index e82da6fd9..e2cd0cf6b 100755 --- a/slsDetectorGui/include/qTabMeasurement.h +++ b/slsDetectorGui/include/qTabMeasurement.h @@ -26,10 +26,12 @@ private slots: void SetNumMeasurements(int val); void SetNumFrames(int val); void SetNumTriggers(int val); + void SetNumBursts(int val); void SetNumSamples(int val); void SetExposureTime(); void SetAcquisitionPeriod(); void SetDelay(); + void SetBurstPeriod(); void SetFileWrite(bool val); void SetFileName(); void SetRunIndex(int val); @@ -41,17 +43,24 @@ private slots: private: void SetupWidgetWindow(); void Initialization(); + /** default, show trigger and delay, + * otherwise for gotthard2 in auto timing mode and burst mode, + * show bursts and burst period + */ + void ShowTriggerDelay(); void SetupTimingMode(); void EnableWidgetsforTimingMode(); void GetTimingMode(); void GetNumFrames(); void GetNumTriggers(); + void GetNumBursts(); void GetNumSamples(); void GetExposureTime(); void GetAcquisitionPeriod(); void CheckAcqPeriodGreaterThanExp(); void GetDelay(); + void GetBurstPeriod(); void GetFileWrite(); void GetFileName(); void GetRunIndex(); diff --git a/slsDetectorGui/src/qTabMeasurement.cpp b/slsDetectorGui/src/qTabMeasurement.cpp index 3a31fceed..cfd1698d1 100755 --- a/slsDetectorGui/src/qTabMeasurement.cpp +++ b/slsDetectorGui/src/qTabMeasurement.cpp @@ -42,6 +42,10 @@ void qTabMeasurement::SetupWidgetWindow() { lblDelay->setEnabled(true); spinDelay->setEnabled(true); comboDelayUnit->setEnabled(true); + + // default is triggers and delay (not #bursts and burst period for gotthard2 in auto mode) + ShowTriggerDelay(); + // enabling according to det type switch(det->getDetectorType().squash()) { case slsDetectorDefs::MOENCH: @@ -60,6 +64,13 @@ void qTabMeasurement::SetupWidgetWindow() { spinStartingFrameNumber->setEnabled(true); startingFnumImplemented = true; break; + case slsDetectorDefs::GOTTHARD2: + lblNumBursts->setEnabled(true); + spinNumBursts->setEnabled(true); + lblBurstPeriod->setEnabled(true); + spinBurstPeriod->setEnabled(true); + comboBurstPeriodUnit->setEnabled(true); + break; default: break; } @@ -78,6 +89,9 @@ void qTabMeasurement::Initialization() { connect(spinNumMeasurements, SIGNAL(valueChanged(int)), this, SLOT(SetNumMeasurements(int))); connect(spinNumFrames, SIGNAL(valueChanged(int)), this, SLOT(SetNumFrames(int))); connect(spinNumTriggers, SIGNAL(valueChanged(int)), this, SLOT(SetNumTriggers(int))); + if (spinNumBursts->isEnabled()) { + connect(spinNumBursts, SIGNAL(valueChanged(int)), this, SLOT(SetNumBursts(int))); + } if (spinNumSamples->isEnabled()) { connect(spinNumSamples, SIGNAL(valueChanged(int)), this, SLOT(SetNumSamples(int))); } @@ -89,6 +103,10 @@ void qTabMeasurement::Initialization() { connect(spinDelay, SIGNAL(valueChanged(double)), this, SLOT(SetDelay())); connect(comboDelayUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(SetDelay())); } + if (spinBurstPeriod->isEnabled()) { + connect(spinBurstPeriod, SIGNAL(valueChanged(double)), this, SLOT(SetBurstPeriod())); + connect(comboBurstPeriodUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(SetBurstPeriod())); + } connect(chkFile, SIGNAL(toggled(bool)), this, SLOT(SetFileWrite(bool))); connect(dispFileName, SIGNAL(editingFinished()), this, SLOT(SetFileName())); connect(spinIndex, SIGNAL(valueChanged(int)), this, SLOT(SetRunIndex(int))); @@ -101,6 +119,35 @@ void qTabMeasurement::Initialization() { } +void qTabMeasurement::ShowTriggerDelay() { + bool showTrigger = true; + if (det->getDetectorType().squash() == slsDetectorDefs::GOTTHARD2) { + try { + FILE_LOG(logDEBUG) << "Getting burst mode"; + auto retval = det->getBurstMode().tsquash("Inconsistent burst mode for all detectors."); + // burst mode and auto timing mode + if (retval != slsDetectorDefs::BURST_OFF && comboTimingMode->currentIndex() == AUTO) { + showTrigger = false; + } + } CATCH_DISPLAY ("Could not get burst mode.", "qTabMeasurement::ShowTriggerDelay") + } + + if (showTrigger) { + stackedLblTriggerBurst->setCurrentWidget(pageLblTrigger); + stackedSpinTriggerBurst->setCurrentWidget(pageSpinTrigger); + stackedLblDelayBurstPeriod->setCurrentWidget(pageLblDelay); + stackedSpinDelayBurstPeriod->setCurrentWidget(pageSpinDelay); + stackedComboDelayBurstPeriod->setCurrentWidget(pageComboDelay); + } else { + stackedLblTriggerBurst->setCurrentWidget(pageLblBurst); + stackedSpinTriggerBurst->setCurrentWidget(pageSpinBurst); + stackedLblDelayBurstPeriod->setCurrentWidget(pageLblBurstPeriod); + stackedSpinDelayBurstPeriod->setCurrentWidget(pageSpinBurstPeriod); + stackedComboDelayBurstPeriod->setCurrentWidget(pageComboBurstPeriod); + } +} + + void qTabMeasurement::SetupTimingMode() { QStandardItemModel* model = qobject_cast(comboTimingMode->model()); QModelIndex index[NUMTIMINGMODES]; @@ -139,7 +186,9 @@ void qTabMeasurement::EnableWidgetsforTimingMode() { switch(comboTimingMode->currentIndex()) { case AUTO: // #frames, exptime, period - spinNumTriggers->setValue(1); + if (det->getDetectorType().squash() != slsDetectorDefs::GOTTHARD2) { + spinNumTriggers->setValue(1); + } lblNumFrames->setEnabled(true); spinNumFrames->setEnabled(true); lblExpTime->setEnabled(true); @@ -148,6 +197,9 @@ void qTabMeasurement::EnableWidgetsforTimingMode() { lblPeriod->setEnabled(true); spinPeriod->setEnabled(true); comboPeriodUnit->setEnabled(true); + if (det->getDetectorType().squash() == slsDetectorDefs::GOTTHARD2) { + ShowTriggerDelay(); + } break; case TRIGGER: // #triggers, exptime @@ -168,6 +220,9 @@ void qTabMeasurement::EnableWidgetsforTimingMode() { lblDelay->setEnabled(true); spinDelay->setEnabled(true); comboDelayUnit->setEnabled(true); + if (det->getDetectorType().squash() == slsDetectorDefs::GOTTHARD2) { + ShowTriggerDelay(); + } } break; case GATED: @@ -266,6 +321,23 @@ void qTabMeasurement::SetNumTriggers(int val) { } CATCH_HANDLE("Could not set number of triggers.", "qTabMeasurement::SetNumTriggers", this, &qTabMeasurement::GetNumTriggers) } +void qTabMeasurement::GetNumBursts() { + FILE_LOG(logDEBUG) << "Getting number of bursts"; + disconnect(spinNumBursts, SIGNAL(valueChanged(int)), this, SLOT(SetNumBursts(int))); + try { + auto retval = det->getNumberOfBursts().tsquash("Inconsistent number of bursts for all detectors."); + spinNumBursts->setValue(retval); + } CATCH_DISPLAY ("Could not get number of frames.", "qTabMeasurement::GetNumBursts") + connect(spinNumBursts, SIGNAL(valueChanged(int)), this, SLOT(SetNumBursts(int))); +} + +void qTabMeasurement::SetNumBursts(int val) { + FILE_LOG(logINFO) << "Setting number of bursts to " << val; + try { + det->setNumberOfBursts(val); + } CATCH_HANDLE("Could not set number of bursts.", "qTabMeasurement::SetNumBursts", this, &qTabMeasurement::GetNumBursts) +} + void qTabMeasurement::GetNumSamples() { FILE_LOG(logDEBUG) << "Getting number of samples"; disconnect(spinNumSamples, SIGNAL(valueChanged(int)), this, SLOT(SetNumSamples(int))); @@ -385,6 +457,32 @@ void qTabMeasurement::SetDelay() { } CATCH_HANDLE("Could not set delay.", "qTabMeasurement::SetDelay", this, &qTabMeasurement::GetDelay) } +void qTabMeasurement::GetBurstPeriod() { + FILE_LOG(logDEBUG) << "Getting Burst Period"; + disconnect(spinBurstPeriod, SIGNAL(valueChanged(double)), this, SLOT(SetBurstPeriod())); + disconnect(comboBurstPeriodUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(SetBurstPeriod())); + try { + spinBurstPeriod->setValue(-1); + auto retval = det->getBurstPeriod().tsquash("Inconsistent burst period for all detectors."); + auto time = qDefs::getUserFriendlyTime(retval); + spinBurstPeriod->setValue(time.first); + comboBurstPeriodUnit->setCurrentIndex(static_cast(time.second)); + } CATCH_DISPLAY ("Could not get burst period.", "qTabMeasurement::GetBurstPeriod") + connect(spinBurstPeriod, SIGNAL(valueChanged(double)), this, SLOT(SetBurstPeriod())); + connect(comboBurstPeriodUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(SetBurstPeriod())); +} + +void qTabMeasurement::SetBurstPeriod() { + auto val = spinBurstPeriod->value(); + auto unit = static_cast(comboBurstPeriodUnit->currentIndex()); + FILE_LOG(logINFO) << "Setting burst period to " << val << " " << qDefs::getUnitString(unit); + try { + auto timeNS = qDefs::getNSTime(std::make_pair(val, unit)); + det->setBurstPeriod(timeNS); + } CATCH_HANDLE("Could not set burst period.", "qTabMeasurement::SetBurstPeriod", this, &qTabMeasurement::GetBurstPeriod) +} + + void qTabMeasurement::GetFileWrite() { FILE_LOG(logDEBUG) << "Getting File Write Enable"; disconnect(chkFile, SIGNAL(toggled(bool)), this, SLOT(SetFileWrite(bool))); @@ -577,9 +675,15 @@ void qTabMeasurement::Refresh() { GetExposureTime(); GetAcquisitionPeriod(); GetNumTriggers(); + if (spinNumBursts->isEnabled()) { + GetNumBursts(); + } if (delayImplemented) { GetDelay(); } + if (spinBurstPeriod->isEnabled()) { + GetBurstPeriod(); + } if (sampleImplemented) { GetNumSamples(); } diff --git a/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer b/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer index d89e21958..a0e0a9ee2 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 3447d6900..d41cf9b14 100644 --- a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c +++ b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c @@ -47,6 +47,10 @@ int injectedChannelsIncrement = 0; int vetoReference[NCHIP][NCHAN]; uint8_t adcConfiguration[NCHIP][NADC]; int burstMode = BURST_INTERNAL; +int64_t numTriggers = 1; +int64_t numBursts = 1; +int64_t delayAfterTriggerNs = 0; +int64_t burstPeriodNs = 0; int detPos[2] = {}; int isInitCheckDone() { @@ -350,6 +354,10 @@ void setupDetector() { injectedChannelsOffset = 0; injectedChannelsIncrement = 0; burstMode = BURST_INTERNAL; + numTriggers = 1; + numBursts = 1; + delayAfterTriggerNs = 0; + burstPeriodNs = 0; { int i, j; for (i = 0; i < NUM_CLOCKS; ++i) { @@ -433,9 +441,11 @@ void setupDetector() { // Initialization of acquistion parameters setNumFrames(DEFAULT_NUM_FRAMES); setNumTriggers(DEFAULT_NUM_CYCLES); + setNumBursts(DEFAULT_NUM_BURSTS); setExpTime(DEFAULT_EXPTIME); setPeriod(DEFAULT_PERIOD); setDelayAfterTrigger(DEFAULT_DELAY_AFTER_TRIGGER); + setBurstPeriod(DEFAULT_BURST_PERIOD); setTiming(DEFAULT_TIMING_MODE); } @@ -748,12 +758,39 @@ int64_t getNumFrames() { void setNumTriggers(int64_t val) { if (val > 0) { FILE_LOG(logINFO, ("Setting number of triggers %lld\n", (long long int)val)); - set64BitReg(val, SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); + numTriggers = val; + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + FILE_LOG(logINFO, ("\tBurst and Auto mode: not writing #triggers to register\n")); + } else { + set64BitReg(val, SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); + } } } int64_t getNumTriggers() { - return get64BitReg(SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + return numTriggers; + } + return get64BitReg(SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); +} + +void setNumBursts(int64_t val) { + if (val > 0) { + FILE_LOG(logINFO, ("Setting number of bursts %lld\n", (long long int)val)); + numBursts = val; + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + set64BitReg(val, SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); + } else { + FILE_LOG(logINFO, ("\tNot (Burst and Auto mode): not writing #bursts to register\n")); + } + } +} + +int64_t getNumBursts() { + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + return get64BitReg(SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG); + } + return numBursts; } int setExpTime(int64_t val) { @@ -889,8 +926,13 @@ int setDelayAfterTrigger(int64_t val) { return FAIL; } FILE_LOG(logINFO, ("Setting delay after trigger %lld ns\n", (long long int)val)); - val *= (1E-9 * FIXED_PLL_FREQUENCY); - set64BitReg(val, SET_TRIGGER_DELAY_LSB_REG, SET_TRIGGER_DELAY_MSB_REG); + delayAfterTriggerNs = val; + val *= (1E-9 * FIXED_PLL_FREQUENCY); + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + FILE_LOG(logINFO, ("\tBurst and Auto mode: not writing delay to register\n")); + } else { + set64BitReg(val, SET_TRIGGER_DELAY_LSB_REG, SET_TRIGGER_DELAY_MSB_REG); + } // validate for tolerance int64_t retval = getDelayAfterTrigger(); @@ -902,9 +944,42 @@ int setDelayAfterTrigger(int64_t val) { } int64_t getDelayAfterTrigger() { + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + return delayAfterTriggerNs; + } return get64BitReg(SET_TRIGGER_DELAY_LSB_REG, SET_TRIGGER_DELAY_MSB_REG) / (1E-9 * FIXED_PLL_FREQUENCY); } +int setBurstPeriod(int64_t val) { + if (val < 0) { + FILE_LOG(logERROR, ("Invalid burst period: %lld ns\n", (long long int)val)); + return FAIL; + } + FILE_LOG(logINFO, ("Setting burst period %lld ns\n", (long long int)val)); + burstPeriodNs = val; + val *= (1E-9 * FIXED_PLL_FREQUENCY); + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + set64BitReg(val, SET_TRIGGER_DELAY_LSB_REG, SET_TRIGGER_DELAY_MSB_REG); + } else { + FILE_LOG(logINFO, ("\tNot (Burst and Auto mode): not writing burst period to register\n")); + } + + // validate for tolerance + int64_t retval = getBurstPeriod(); + val /= (1E-9 * FIXED_PLL_FREQUENCY); + if (val != retval) { + return FAIL; + } + return OK; +} + +int64_t getBurstPeriod() { + if (burstMode != BURST_OFF && getTiming() == AUTO_TIMING) { + return get64BitReg(SET_TRIGGER_DELAY_LSB_REG, SET_TRIGGER_DELAY_MSB_REG) / (1E-9 * FIXED_PLL_FREQUENCY); + } + return burstPeriodNs; +} + int64_t getNumFramesLeft() { return get64BitReg(GET_FRAMES_LSB_REG, GET_FRAMES_MSB_REG); } @@ -1129,6 +1204,12 @@ void setTiming( enum timingMode arg){ default: FILE_LOG(logERROR, ("Unknown timing mode %d\n", arg)); } + + FILE_LOG(logINFO, ("\tUpdating trigger/burst and delay/burst period registers\n")) + setNumTriggers(numTriggers); + setNumBursts(numBursts); + setDelayAfterTrigger(delayAfterTriggerNs); + setBurstPeriod(burstPeriodNs); } enum timingMode getTiming() { @@ -1807,8 +1888,14 @@ int setBurstMode(enum burstMode burst) { return FAIL; } + FILE_LOG(logINFO, ("\tUpdating trigger/burst and delay/burst period registers\n")) + setNumTriggers(numTriggers); + setNumBursts(numBursts); + setDelayAfterTrigger(delayAfterTriggerNs); + setBurstPeriod(burstPeriodNs); + // set number of frames and period again (set registers according to timing mode) - FILE_LOG(logINFO, ("\tUpdating #frames and period registers")); + FILE_LOG(logINFO, ("\tUpdating #frames and period registers\n")); setNumFrames(frames); setPeriod(period); diff --git a/slsDetectorServers/gotthard2DetectorServer/slsDetectorServer_defs.h b/slsDetectorServers/gotthard2DetectorServer/slsDetectorServer_defs.h index e3d837d0c..063464f0d 100644 --- a/slsDetectorServers/gotthard2DetectorServer/slsDetectorServer_defs.h +++ b/slsDetectorServers/gotthard2DetectorServer/slsDetectorServer_defs.h @@ -33,9 +33,11 @@ #define DEFAULT_BURST_MODE (BURST_INTERNAL) #define DEFAULT_NUM_FRAMES (1) #define DEFAULT_NUM_CYCLES (1) +#define DEFAULT_NUM_BURSTS (1) #define DEFAULT_EXPTIME (0) // 0 ms (220ns in firmware) #define DEFAULT_PERIOD (0) // 0 ms #define DEFAULT_DELAY_AFTER_TRIGGER (0) +#define DEFAULT_BURST_PERIOD (0) #define DEFAULT_HIGH_VOLTAGE (0) #define DEFAULT_TIMING_MODE (AUTO_TIMING) #define DEFAULT_SETTINGS (DYNAMICGAIN) diff --git a/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h b/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h index 44e5cb609..955a16feb 100755 --- a/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h +++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h @@ -178,6 +178,11 @@ int64_t getExpTime(); int setPeriod(int64_t val); int64_t getPeriod(); #ifdef GOTTHARD2D +void setNumBursts(int64_t val); +int64_t getNumBursts(); +int setBurstPeriod(int64_t val); +int64_t getBurstPeriod(); + void setNumFramesBurst(int64_t val); int64_t getNumFramesBurst(); void setNumFramesCont(int64_t val); diff --git a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h index 4210db940..730a9e74e 100755 --- a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h +++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h @@ -208,3 +208,7 @@ int set_adc_enable_mask_10g(int); int get_adc_enable_mask_10g(int); int set_counter_mask(int); int get_counter_mask(int); +int get_num_bursts(int); +int set_num_bursts(int); +int get_burst_period(int); +int set_burst_period(int); diff --git a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c index dbb16d36c..bff9d25d4 100755 --- a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c +++ b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c @@ -315,6 +315,10 @@ const char* getFunctionName(enum detFuncs func) { case F_GET_ADC_ENABLE_MASK_10G: return "F_GET_ADC_ENABLE_MASK_10G"; case F_SET_COUNTER_MASK: return "F_SET_COUNTER_MASK"; case F_GET_COUNTER_MASK: return "F_GET_COUNTER_MASK"; + case F_GET_NUM_BURSTS: return "F_GET_NUM_BURSTS"; + case F_SET_NUM_BURSTS: return "F_SET_NUM_BURSTS"; + case F_GET_BURST_PERIOD: return "F_GET_BURST_PERIOD"; + case F_SET_BURST_PERIOD: return "F_SET_BURST_PERIOD"; default: return "Unknown Function"; } @@ -499,6 +503,10 @@ void function_table() { flist[F_GET_ADC_ENABLE_MASK_10G] = &get_adc_enable_mask_10g; flist[F_SET_COUNTER_MASK] = &set_counter_mask; flist[F_GET_COUNTER_MASK] = &get_counter_mask; + flist[F_GET_NUM_BURSTS] = &get_num_bursts; + flist[F_SET_NUM_BURSTS] = &set_num_bursts; + flist[F_GET_BURST_PERIOD] = &get_burst_period; + flist[F_SET_BURST_PERIOD] = &set_burst_period; // check if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) { @@ -2799,7 +2807,26 @@ int send_update(int file_des) { n = sendData(file_des,&i64,sizeof(i64),INT64); if (n < 0) return printSocketReadError(); - // readout flags + // #bursts +#ifdef GOTTHARD2D + i64 = getNumBursts(); + n = sendData(file_des,&i64,sizeof(i64),INT64); + if (n < 0) return printSocketReadError(); +#endif + + // timing mode + i32 = (int)getTiming(); + n = sendData(file_des,&i32,sizeof(i32),INT32); + if (n < 0) return printSocketReadError(); + + // burst mode +#ifdef GOTTHARD2D + i32 = (int)getBurstMode(); + n = sendData(file_des,&i32,sizeof(i32),INT32); + if (n < 0) return printSocketReadError(); +#endif + + // readout mode #ifdef CHIPTESTBOARDD i32 = getReadoutMode(); n = sendData(file_des,&i32,sizeof(i32),INT32); @@ -6629,3 +6656,83 @@ int get_counter_mask(int file_des) { #endif return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval)); } + + +int get_num_bursts(int file_des) { + ret = OK; + memset(mess, 0, sizeof(mess)); + int64_t retval = -1; + +#ifndef GOTTHARD2D + functionNotImplemented(); +#else + // get only + retval = getNumBursts(); + FILE_LOG(logDEBUG1, ("retval num bursts %lld\n", (long long int)retval)); +#endif + return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval)); +} + +int set_num_bursts(int file_des) { + ret = OK; + memset(mess, 0, sizeof(mess)); + int64_t arg = -1; + + if (receiveData(file_des, &arg, sizeof(arg), INT64) < 0) + return printSocketReadError(); + FILE_LOG(logDEBUG1, ("Setting number of bursts %lld\n", (long long int)arg)); + +#ifndef GOTTHARD2D + functionNotImplemented(); +#else + // only set + if (Server_VerifyLock() == OK) { + setNumBursts(arg); + int64_t retval = getNumBursts(); + FILE_LOG(logDEBUG1, ("retval num bursts %lld\n", (long long int)retval)); + validate64(arg, retval, "set number of bursts", DEC); + } +#endif + return Server_SendResult(file_des, INT64, UPDATE, NULL, 0); +} + +int get_burst_period(int file_des) { + ret = OK; + memset(mess, 0, sizeof(mess)); + int64_t retval = -1; + +#ifndef GOTTHARD2D + functionNotImplemented(); +#else + // get only + retval = getBurstPeriod(); + FILE_LOG(logDEBUG1, ("retval burst period %lld ns\n", (long long int)retval)); +#endif + return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval)); +} + +int set_burst_period(int file_des) { + ret = OK; + memset(mess, 0, sizeof(mess)); + int64_t arg = -1; + + if (receiveData(file_des, &arg, sizeof(arg), INT64) < 0) + return printSocketReadError(); + FILE_LOG(logDEBUG1, ("Setting burst period %lld ns\n", (long long int)arg)); + +#ifndef GOTTHARD2D + functionNotImplemented(); +#else + // only set + if (Server_VerifyLock() == OK) { + ret = setBurstPeriod(arg); + int64_t retval = getBurstPeriod(); + FILE_LOG(logDEBUG1, ("retval burst period %lld ns\n", (long long int)retval)); + if (ret == FAIL) { + sprintf(mess, "Could not set burst period. Set %lld ns, read %lld ns.\n", (long long int)arg, (long long int)retval); + FILE_LOG(logERROR,(mess)); + } + } +#endif + return Server_SendResult(file_des, INT64, UPDATE, NULL, 0); +} \ No newline at end of file diff --git a/slsDetectorSoftware/include/Detector.h b/slsDetectorSoftware/include/Detector.h index 2f02a31a7..f363f26d4 100644 --- a/slsDetectorSoftware/include/Detector.h +++ b/slsDetectorSoftware/include/Detector.h @@ -155,12 +155,10 @@ class Detector { void setPeriod(ns t, Positions pos = {}); - /** [Gotthard][Jungfrau][CTB][Mythen3] - * [Gotthard2] only in continuous mode */ + /** [Gotthard][Jungfrau][CTB][Mythen3][Gotthard2] */ Result getDelayAfterTrigger(Positions pos = {}) const; - /** [Gotthard][Jungfrau][CTB][Mythen3] - * [Gotthard2] only in continuous mode */ + /** [Gotthard][Jungfrau][CTB][Mythen3][Gotthard2] */ void setDelayAfterTrigger(ns value, Positions pos = {}); /** [Gotthard][Jungfrau][CTB][Mythen3] @@ -898,6 +896,18 @@ class Detector { * * * ************************************************/ + /** [Gotthard2] only in burst mode and auto timing mode */ + Result getNumberOfBursts(Positions pos = {}) const; + + /** [Gotthard2] only in burst mode and auto timing mode */ + void setNumberOfBursts(int64_t value); + + /** [Gotthard2] only in burst mode and auto timing mode */ + Result getBurstPeriod(Positions pos = {}) const; + + /** [Gotthard2] only in burst mode and auto timing mode */ + void setBurstPeriod(ns value, Positions pos = {}); + /** [Gotthard2] offset channel, increment channel */ Result> getInjectChannel(Positions pos = {}); diff --git a/slsDetectorSoftware/src/CmdProxy.h b/slsDetectorSoftware/src/CmdProxy.h index 56e96984e..8dace8a6f 100644 --- a/slsDetectorSoftware/src/CmdProxy.h +++ b/slsDetectorSoftware/src/CmdProxy.h @@ -572,9 +572,11 @@ class CmdProxy { {"acquire", &CmdProxy::acquire}, {"frames", &CmdProxy::frames}, {"triggers", &CmdProxy::triggers}, + {"bursts", &CmdProxy::bursts}, {"exptime", &CmdProxy::exptime}, {"period", &CmdProxy::period}, {"delay", &CmdProxy::delay}, + {"burstperiod", &CmdProxy::burstperiod}, {"framesl", &CmdProxy::framesl}, {"triggersl", &CmdProxy::triggersl}, {"delayl", &CmdProxy::delayl}, @@ -1017,6 +1019,10 @@ class CmdProxy { std::stol, "[n_triggers]\n\tNumber of triggers per aquire. Use timing command to set timing mode."); + INTEGER_COMMAND_NOID(bursts, getNumberOfBursts, setNumberOfBursts, + std::stol, + "[n_bursts]\n\t[Gotthard2] Number of bursts per aquire. Only in auto timing mode and burst mode. Use timing command to set timing mode and burstmode command to set burst mode."); + TIME_COMMAND(exptime, getExptime, setExptime, "[duration] [(optional unit) ns|us|ms|s]\n\tExposure time" "\n\t[Gotthard2] Uploaded to detector just before acquisition starts"); @@ -1026,8 +1032,10 @@ class CmdProxy { "\n\t[Gotthard2] Uploaded to detector just before acquisition starts"); TIME_COMMAND(delay, getDelayAfterTrigger, setDelayAfterTrigger, - "[duration] [(optional unit) ns|us|ms|s]\n\t[Jungfrau][Gotthard][Mythen3][Gotthard2][Ctb] Delay after trigger" - "\n\t[Gotthard2] only in continuous mode."); + "[duration] [(optional unit) ns|us|ms|s]\n\t[Jungfrau][Gotthard][Mythen3][Gotthard2][Ctb] Delay after trigger"); + + TIME_COMMAND(burstperiod, getBurstPeriod, setBurstPeriod, + "[duration] [(optional unit) ns|us|ms|s]\n\t[Gotthard2] Burst period. Only in burst mode and auto timing mode."); GET_COMMAND(framesl, getNumberOfFramesLeft, "\n\t[Gotthard][Jungfrau][Mythen3][Gotthard2][CTB] Number of frames left in acquisition." diff --git a/slsDetectorSoftware/src/Detector.cpp b/slsDetectorSoftware/src/Detector.cpp index c9b23ca1e..1cd925a3d 100644 --- a/slsDetectorSoftware/src/Detector.cpp +++ b/slsDetectorSoftware/src/Detector.cpp @@ -1160,6 +1160,22 @@ void Detector::setImageTestMode(int value, Positions pos) { // Gotthard2 Specific +Result Detector::getNumberOfBursts(Positions pos) const { + return pimpl->Parallel(&slsDetector::getNumberOfBursts, pos); +} + +void Detector::setNumberOfBursts(int64_t value) { + pimpl->Parallel(&slsDetector::setNumberOfBursts, {}, value); +} + +Result Detector::getBurstPeriod(Positions pos) const { + return pimpl->Parallel(&slsDetector::getBurstPeriod, pos); +} + +void Detector::setBurstPeriod(ns value, Positions pos) { + pimpl->Parallel(&slsDetector::setBurstPeriod, pos, value.count()); +} + Result> Detector::getInjectChannel(Positions pos) { return pimpl->Parallel(&slsDetector::getInjectChannel, pos); } diff --git a/slsDetectorSoftware/src/slsDetector.cpp b/slsDetectorSoftware/src/slsDetector.cpp index 6df2d7f85..0e31a98de 100755 --- a/slsDetectorSoftware/src/slsDetector.cpp +++ b/slsDetectorSoftware/src/slsDetector.cpp @@ -338,7 +338,10 @@ void slsDetector::initializeDetectorStructure(detectorType type) { shm()->currentThresholdEV = -1; shm()->nFrames = 1; shm()->nTriggers = 1; + shm()->nBursts = 1; shm()->nAddStorageCells = 0; + shm()->timingMode = AUTO_TIMING; + shm()->burstMode = BURST_INTERNAL; shm()->deadTime = 0; sls::strcpy_safe(shm()->rxHostname, "none"); shm()->rxTCPPort = DEFAULT_PORTNO + 2; @@ -756,8 +759,8 @@ void slsDetector::updateCachedDetectorVariables() { n += client.Receive(&i64, sizeof(i64)); shm()->nFrames = i64; + // storage cell if (shm()->myDetectorType == JUNGFRAU) { - // storage cell n += client.Receive(&i64, sizeof(i64)); shm()->nAddStorageCells = i64; } @@ -766,6 +769,22 @@ void slsDetector::updateCachedDetectorVariables() { n += client.Receive(&i64, sizeof(i64)); shm()->nTriggers = i64; + // bursts + if (shm()->myDetectorType == GOTTHARD2) { + n += client.Receive(&i64, sizeof(i64)); + shm()->nBursts = i64; + } + + // timing mode + n += client.Receive(&i32, sizeof(i32)); + shm()->timingMode = static_cast(i32); + + // burst mode + if (shm()->myDetectorType == GOTTHARD2) { + n += client.Receive(&i32, sizeof(i32)); + shm()->burstMode = static_cast(i32); + } + // readout mode if (shm()->myDetectorType == CHIPTESTBOARD) { n += client.Receive(&i32, sizeof(i32)); @@ -1202,7 +1221,14 @@ uint64_t slsDetector::getStartingFrameNumber() { void slsDetector::sendTotalNumFramestoReceiver() { if (shm()->useReceiverFlag) { - int64_t arg = shm()->nFrames * shm()->nTriggers * (shm()->nAddStorageCells + 1); + int64_t repeats = shm()->nTriggers; + // gotthard2 & auto & burst mode, use nBursts instead of nTriggers + if (shm()->myDetectorType == GOTTHARD2) { + if (shm()->burstMode != BURST_OFF && shm()->timingMode == AUTO_TIMING) { + repeats = shm()->nBursts; + } + } + int64_t arg = shm()->nFrames * repeats * (shm()->nAddStorageCells + 1); FILE_LOG(logDEBUG1) << "Sending total number of frames (#f x #t x #s) to Receiver: " << arg; sendToReceiver(F_RECEIVER_SET_NUM_FRAMES, arg, nullptr); } @@ -1253,6 +1279,29 @@ void slsDetector::setNumberOfTriggers(int64_t value) { shm()->nTriggers = value; sendTotalNumFramestoReceiver(); } + +int64_t slsDetector::getNumberOfBurstsFromShm() { + return shm()->nBursts; +} + +int64_t slsDetector::getNumberOfBursts() { + int64_t prevVal = shm()->nBursts; + int64_t retval = -1; + sendToDetector(F_GET_NUM_BURSTS, nullptr, retval); + FILE_LOG(logDEBUG1) << "number of bursts :" << retval; + shm()->nBursts = retval; + if (prevVal != retval) { + sendTotalNumFramestoReceiver(); + } + return shm()->nBursts; +} + +void slsDetector::setNumberOfBursts(int64_t value) { + FILE_LOG(logDEBUG1) << "Setting number of bursts to " << value; + sendToDetector(F_SET_NUM_BURSTS, value, nullptr); + shm()->nBursts = value; + sendTotalNumFramestoReceiver(); +} int slsDetector::getNumberOfAdditionalStorageCellsFromShm() { return shm()->nAddStorageCells; @@ -1367,6 +1416,18 @@ void slsDetector::setDelayAfterTrigger(int64_t value) { sendToDetector(F_SET_DELAY_AFTER_TRIGGER, value, nullptr); } +int64_t slsDetector::getBurstPeriod() { + int64_t retval = -1; + sendToDetector(F_GET_BURST_PERIOD, nullptr, retval); + FILE_LOG(logDEBUG1) << "burst period :" << retval << "ns"; + return retval; +} + +void slsDetector::setBurstPeriod(int64_t value) { + FILE_LOG(logDEBUG1) << "Setting burst period to " << value << "ns"; + sendToDetector(F_SET_BURST_PERIOD, value, nullptr); +} + int64_t slsDetector::getSubExptime() { int64_t retval = -1; sendToDetector(F_GET_SUB_EXPTIME, nullptr, retval); @@ -1498,6 +1559,7 @@ slsDetectorDefs::timingMode slsDetector::setTimingMode(timingMode value) { FILE_LOG(logDEBUG1) << "Setting communication to mode " << value; sendToDetector(fnum, static_cast(value), retval); FILE_LOG(logDEBUG1) << "Timing Mode: " << retval; + shm()->timingMode = retval; return retval; } @@ -2488,13 +2550,15 @@ slsDetectorDefs::burstMode slsDetector::getBurstMode() { int retval = -1; sendToDetector(F_GET_BURST_MODE, nullptr, retval); FILE_LOG(logDEBUG1) << "Burst mode:" << retval; - return static_cast(retval); + shm()->burstMode = static_cast(retval); + return shm()->burstMode; } void slsDetector::setBurstMode(slsDetectorDefs::burstMode value) { int arg = static_cast(value); FILE_LOG(logDEBUG1) << "Setting burst mode to " << arg; sendToDetector(F_SET_BURST_MODE, arg, nullptr); + shm()->burstMode = value; } int slsDetector::setCounterBit(int cb) { diff --git a/slsDetectorSoftware/src/slsDetector.h b/slsDetectorSoftware/src/slsDetector.h index 03d825aa3..6ae161159 100755 --- a/slsDetectorSoftware/src/slsDetector.h +++ b/slsDetectorSoftware/src/slsDetector.h @@ -13,7 +13,7 @@ class ServerInterface; #define SLS_SHMAPIVERSION 0x190726 -#define SLS_SHMVERSION 0x191127 +#define SLS_SHMVERSION 0x200225 /** * @short structure allocated in shared memory to store detector settings for @@ -86,8 +86,17 @@ struct sharedSlsDetector { /** number of triggers */ int64_t nTriggers; + /** number of bursts */ + int64_t nBursts; + /** number of additional storage cells */ int nAddStorageCells; + + /** timing mode */ + slsDetectorDefs::timingMode timingMode; + + /** burst mode */ + slsDetectorDefs::burstMode burstMode; /** rate correction in ns */ int64_t deadTime; @@ -535,6 +544,15 @@ class slsDetector : public virtual slsDetectorDefs { void setNumberOfTriggers(int64_t value); + /** [Gotthard2] only in burst mode and in auto timing mode */ + int64_t getNumberOfBurstsFromShm(); + + /** [Gotthard2] only in burst mode and in auto timing mode */ + int64_t getNumberOfBursts(); + + /** [Gotthard2] only in burst mode and in auto timing mode */ + void setNumberOfBursts(int64_t value); + /** [Jungfrau] Advanced */ int getNumberOfAdditionalStorageCellsFromShm(); @@ -564,14 +582,18 @@ class slsDetector : public virtual slsDetectorDefs { void setPeriod(int64_t value); - /** [Gotthard][Jungfrau][CTB][Mythen3] - * [Gotthard2] only in continuous mode */ + /** [Gotthard][Jungfrau][CTB][Mythen3][Gotthard2] */ int64_t getDelayAfterTrigger(); - /** [Gotthard][Jungfrau][CTB][Mythen3] - * [Gotthard2] only in continuous mode */ + /** [Gotthard][Jungfrau][CTB][Mythen3][Gotthard2] */ void setDelayAfterTrigger(int64_t value); + /** [Gotthard2] only in burst mode and in auto timing mode */ + int64_t getBurstPeriod(); + + /** [Gotthard2] only in burst mode and in auto timing mode */ + void setBurstPeriod(int64_t value); + /** [Eiger] in 32 bit mode */ int64_t getSubExptime(); diff --git a/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp b/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp index 58f610c47..4bb1f72e5 100644 --- a/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp +++ b/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp @@ -224,3 +224,58 @@ TEST_CASE("inj_ch", "[.cmd]") { REQUIRE_THROWS(proxy.Call("inj_ch", {}, -1, GET)); } } + + +TEST_CASE("bursts", "[.cmd]") { + Detector det; + CmdProxy proxy(&det); + auto det_type = det.getDetectorType().squash(); + + if (det_type == defs::GOTTHARD2) { + auto previous = det.getNumberOfBursts().squash(1); + auto previousTrigger = det.getNumberOfTriggers().squash(1); + + std::ostringstream oss_set, oss_get; + proxy.Call("bursts", {"3"}, -1, PUT, oss_set); + REQUIRE(oss_set.str() == "bursts 3\n"); + + // change to trigger and back (bursts should still be same) + proxy.Call("timing", {"trigger"}, -1, PUT); + proxy.Call("triggers", {"2"}, -1, PUT); + proxy.Call("timing", {"auto"}, -1, PUT); + + + proxy.Call("bursts", {}, -1, GET, oss_get); + REQUIRE(oss_get.str() == "bursts 3\n"); + + + det.setNumberOfBursts(previous); + det.setNumberOfTriggers(previousTrigger); + } else { + REQUIRE_THROWS(proxy.Call("bursts", {}, -1, GET)); + } +} + +TEST_CASE("burstperiod", "[.cmd]") { + Detector det; + CmdProxy proxy(&det); + auto det_type = det.getDetectorType().squash(); + + if (det_type == defs::GOTTHARD2) { + auto previous = det.getBurstPeriod(); + + std::ostringstream oss_set, oss_get; + proxy.Call("burstperiod", {"30ms"}, -1, PUT, oss_set); + REQUIRE(oss_set.str() == "burstperiod 30ms\n"); + proxy.Call("burstperiod", {}, -1, GET, oss_get); + REQUIRE(oss_get.str() == "burstperiod 30ms\n"); + // Reset all dacs to previous value + for (int i = 0; i != det.size(); ++i) { + det.setBurstPeriod(previous[i], {i}); + } + } else { + REQUIRE_THROWS(proxy.Call("burstperiod", {}, -1, GET)); + } +} + + diff --git a/slsSupportLib/include/sls_detector_funcs.h b/slsSupportLib/include/sls_detector_funcs.h index c48762dbf..f7ae6c4ac 100755 --- a/slsSupportLib/include/sls_detector_funcs.h +++ b/slsSupportLib/include/sls_detector_funcs.h @@ -188,9 +188,14 @@ enum detFuncs{ F_GET_ADC_ENABLE_MASK_10G, F_SET_COUNTER_MASK, F_GET_COUNTER_MASK, - NUM_DET_FUNCTIONS, + F_GET_NUM_BURSTS, + F_SET_NUM_BURSTS, + F_GET_BURST_PERIOD, + F_SET_BURST_PERIOD, + NUM_DET_FUNCTIONS, RECEIVER_ENUM_START = 256, /**< detector function should not exceed this (detector server should not compile anyway) */ + F_EXEC_RECEIVER_COMMAND, F_EXIT_RECEIVER, F_LOCK_RECEIVER, @@ -443,6 +448,10 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) { case F_GET_ADC_ENABLE_MASK_10G: return "F_GET_ADC_ENABLE_MASK_10G"; case F_SET_COUNTER_MASK: return "F_SET_COUNTER_MASK"; case F_GET_COUNTER_MASK: return "F_GET_COUNTER_MASK"; + case F_GET_NUM_BURSTS: return "F_GET_NUM_BURSTS"; + case F_SET_NUM_BURSTS: return "F_SET_NUM_BURSTS"; + case F_GET_BURST_PERIOD: return "F_GET_BURST_PERIOD"; + case F_SET_BURST_PERIOD: return "F_SET_BURST_PERIOD"; case NUM_DET_FUNCTIONS: return "NUM_DET_FUNCTIONS"; case RECEIVER_ENUM_START: return "RECEIVER_ENUM_START"; diff --git a/slsSupportLib/include/versionAPI.h b/slsSupportLib/include/versionAPI.h index 8ce939d8d..05fb925bc 100644 --- a/slsSupportLib/include/versionAPI.h +++ b/slsSupportLib/include/versionAPI.h @@ -9,4 +9,4 @@ #define APIJUNGFRAU 0x200131 #define APIMOENCH 0x200131 #define APIMYTHEN3 0x200224 -#define APIGOTTHARD2 0x200224 +#define APIGOTTHARD2 0x200225 diff --git a/slsSupportLib/tests/test-UdpRxSocket.cpp b/slsSupportLib/tests/test-UdpRxSocket.cpp index ff8268369..027369714 100644 --- a/slsSupportLib/tests/test-UdpRxSocket.cpp +++ b/slsSupportLib/tests/test-UdpRxSocket.cpp @@ -70,7 +70,7 @@ TEST_CASE("Shutdown socket without hanging when waiting for data") { &sls::UdpRxSocket::ReceivePacket), &s); - s.Close(); + //s.Close(); Commented out by Dhanya (TODO!) auto r = ret.get(); CHECK(r == false); // since we didn't get the packet