gotthard2: bursts and burst period, written to same register as triggers and delay (kept in server as variables) and set if conditions meet. bursts and burst period only in auto timing and burst mode. Also updating theses registers when switching between timing modes or burst modes

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);
 

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)

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);

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);

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);
+}