Separate headers (#57)

* WIP, ctb

* WIP, eiger

* WIP, gotthard

* WIP, jungfrau

* WIP, gotthard2

* WIP, mythen3

* WIP, moench

* fixed gotthard apiversioning mismatch with gotthard2

slsDetectorServers/slsDetectorServer/include/AD7689.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Set Defines
+ * @param reg spi register
+ * @param roreg spi readout register
+ * @param cmsk conversion mask
+ * @param clkmsk clock output mask
+ * @param dmsk digital output mask
+ * @param dofst digital output offset
+ */
+void AD7689_SetDefines(uint32_t reg, uint32_t roreg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst);
+
+/**
+ * Disable SPI
+ */
+void AD7689_Disable();
+
+/**
+ * Set SPI reg value
+ * @param codata value to be set
+ */
+void AD7689_Set(uint32_t codata);
+
+/**
+ * Get SPI reg value
+ * @returns SPI reg value
+ */
+uint16_t AD7689_Get();
+
+/**
+ * Get temperature
+ * @returns temperature in °C
+ */
+int AD7689_GetTemperature();
+
+/**
+ * Reads channels voltage
+ * @param ichan channel number from 0 to 7
+ * @returns channel voltage in mV
+ */
+int AD7689_GetChannel(int ichan);
+
+/**
+ * Configure
+ */
+void AD7689_Configure();

slsDetectorServers/slsDetectorServer/include/AD9252.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Set Defines
+ * @param reg spi register
+ * @param cmsk chip select mask
+ * @param clkmsk clock output mask
+ * @param dmsk digital output mask
+ * @param dofst digital output offset
+ */
+void AD9252_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst);
+
+/**
+ * Disable SPI
+ */
+void AD9252_Disable();
+
+/**
+ * Set SPI reg value
+ * @param codata value to be set
+ */
+void AD9252_Set(int addr, int val);
+
+/**
+ * Configure
+ */
+void AD9252_Configure();

slsDetectorServers/slsDetectorServer/include/AD9257.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Set Defines
+ * @param reg spi register
+ * @param cmsk chip select mask
+ * @param clkmsk clock output mask
+ * @param dmsk digital output mask
+ * @param dofst digital output offset
+ */
+void AD9257_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst);
+
+/**
+ * Disable SPI
+ */
+void AD9257_Disable() ;
+
+/**
+ * Get vref voltage
+ */
+int AD9257_GetVrefVoltage(int mV);
+
+/**
+ * Set vref voltage
+ * @param val voltage to be set (0 for 1.0V, 1 for 1.14V, 2 for 1.33V, 3 for 1.6V, 4 for 2.0V
+ * @returns ok or fail
+ */
+int AD9257_SetVrefVoltage(int val, int mV);
+
+/**
+ * Set SPI reg value
+ * @param codata value to be set
+ */
+void AD9257_Set(int addr, int val);
+
+/**
+ * Configure
+ */
+void AD9257_Configure();

slsDetectorServers/slsDetectorServer/include/ALTERA_PLL.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Set Defines
+ * @param creg control register
+ * @param preg parameter register
+ * @param rprmsk reconfig parameter reset mask
+ * @param wpmsk write parameter mask
+ * @param prmsk pll reset mask
+ * @param amsk address mask
+ * @param aofst address offset
+ */
+void ALTERA_PLL_SetDefines(uint32_t creg, uint32_t preg, uint32_t rprmsk, uint32_t wpmsk, uint32_t prmsk, uint32_t amsk, int aofst);
+
+/**
+ * Reset only PLL
+ */
+void ALTERA_PLL_ResetPLL ();
+
+/**
+ * Reset PLL Reconfiguration and PLL
+ */
+void ALTERA_PLL_ResetPLLAndReconfiguration ();
+
+/**
+ * Set PLL Reconfig register
+ * @param reg register
+ * @param val value
+ */
+void ALTERA_PLL_SetPllReconfigReg(uint32_t reg, uint32_t val);
+
+/**
+ * Write Phase Shift
+ * @param phase phase shift
+ * @param clkIndex clock index
+ * @param pos 1 if up down direction of shift is positive, else 0
+ */
+void ALTERA_PLL_SetPhaseShift(int32_t phase, int clkIndex, int pos);
+
+/**
+ * Set PLL mode register to polling mode
+ */
+void ALTERA_PLL_SetModePolling();
+/**
+ * Calculate and write output frequency
+ * @param clkIndex clock index
+ * @param pllVCOFreqMhz PLL VCO Frequency in Mhz
+ * @param value frequency to set to
+ * @param frequency set
+ */
+int ALTERA_PLL_SetOuputFrequency (int clkIndex, int pllVCOFreqMhz, int value);
+

slsDetectorServers/slsDetectorServer/include/I2C.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Configure the I2C core,
+ * Enable core and
+ * Calibrate the calibration register for current readout
+ * @param creg control register (defined in RegisterDefs.h)
+ * @param sreg status register (defined in RegisterDefs.h)
+ * @param rreg rx data fifo register (defined in RegisterDefs.h)
+ * @param rlvlreg rx data fifo level register (defined in RegisterDefs.h)
+ * @param slreg scl low count register (defined in RegisterDefs.h)
+ * @param shreg scl high count register (defined in RegisterDefs.h)
+ * @param sdreg sda hold register (defined in RegisterDefs.h)
+ * @param treg transfer command fifo register (defined in RegisterDefs.h)
+ */
+void I2C_ConfigureI2CCore(uint32_t creg, uint32_t sreg,
+        uint32_t rreg, uint32_t rlvlreg,
+        uint32_t slreg, uint32_t shreg, uint32_t sdreg, uint32_t treg);
+
+/**
+ * Read register
+ * @param deviceId device Id
+ * @param addr register address
+ * @returns value read from register
+ */
+uint32_t I2C_Read(uint32_t devId, uint32_t addr);
+
+/**
+ * Write register (16 bit value)
+ * @param deviceId device Id
+ * @param addr register address
+ * @param data data to be written (16 bit)
+ */
+void I2C_Write(uint32_t devId, uint32_t addr, uint16_t data);
+
+

slsDetectorServers/slsDetectorServer/include/INA226.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Configure the I2C core and Enable core
+ * @param rOhm shunt resister value in Ohms (defined in slsDetectorServer_defs.h)
+ * @param creg control register (defined in RegisterDefs.h)
+ * @param sreg status register (defined in RegisterDefs.h)
+ * @param rreg rx data fifo register (defined in RegisterDefs.h)
+ * @param rlvlreg rx data fifo level register (defined in RegisterDefs.h)
+ * @param slreg scl low count register (defined in RegisterDefs.h)
+ * @param shreg scl high count register (defined in RegisterDefs.h)
+ * @param sdreg sda hold register (defined in RegisterDefs.h)
+ * @param treg transfer command fifo register (defined in RegisterDefs.h)
+ */
+void INA226_ConfigureI2CCore(double rOhm, uint32_t creg, uint32_t sreg,
+        uint32_t rreg, uint32_t rlvlreg,
+        uint32_t slreg, uint32_t shreg, uint32_t sdreg, uint32_t treg);
+
+/**
+ * Calibrate resolution of current register
+ * @param deviceId device Id (defined in slsDetectorServer_defs.h)
+ */
+void INA226_CalibrateCurrentRegister(uint32_t deviceId);
+
+/**
+ * Read voltage of device
+ * @param deviceId device Id
+ * @returns voltage in mV
+ */
+int INA226_ReadVoltage(uint32_t deviceId);
+
+/**
+ * Read current
+ * @param deviceId device Id
+ * @returns current in mA
+ */
+int INA226_ReadCurrent(uint32_t deviceId);

slsDetectorServers/slsDetectorServer/include/LTC2620.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Set Defines
+ * @param reg spi register
+ * @param cmsk chip select mask
+ * @param clkmsk clock output mask
+ * @param dmsk digital output mask
+ * @param dofst digital output offset
+ * @param nd total number of dacs for this board (for dac channel and daisy chain chip id)
+ * @param minMV minimum voltage determined by hardware
+ * @param maxMV maximum voltage determined by hardware
+ */
+void LTC2620_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst, int nd, int minMV, int maxMV);
+
+/**
+ * Disable SPI
+ */
+void LTC2620_Disable();
+
+/**
+ * Get power down value
+ */
+int LTC2620_GetPowerDownValue();
+
+/**
+ * Get minimum input value for dac
+ */
+int LTC2620_GetMinInput();
+
+/**
+ * Get maximum input value for dac
+ */
+int LTC2620_GetMaxInput();
+
+/**
+ * Get max number of steps
+ */
+int LTC2620_GetMaxNumSteps();
+
+/**
+ * Convert voltage to dac units
+ * @param voltage value in mv
+ * @param dacval pointer to value converted to dac units
+ * @returns FAIL when voltage outside limits, OK if conversion successful
+ */
+int LTC2620_VoltageToDac(int voltage, int* dacval);
+
+/**
+ * Convert dac units to voltage
+ * @param dacval dac units
+ * @param voltage pointer to value converted to mV
+ * @returns FAIL when voltage outside limits, OK if conversion successful
+ */
+int LTC2620_DacToVoltage(int dacval, int* voltage);
+
+/**
+ * Set a single chip (all non ctb detectors use this)
+ * when max dac is 8
+ * @param cmd command
+ * @param data dac value to be set
+ * @param dacaddr dac channel number in chip
+ */
+void LTC2620_SetSingle(int cmd, int data, int dacaddr);
+
+/**
+ * bit bang the data into all the chips daisy fashion
+ * @param valw current value of register while bit banging
+ * @param val data to be sent (data, dac addr and command)
+ */
+void LTC2620_SendDaisyData(uint32_t* valw, uint32_t val);
+
+/**
+ * Set a single chip (all non ctb detectors use this)
+ * when max dac is 8
+ * @param cmd command
+ * @param data dac value to be set
+ * @param dacaddr dac channel number in chip
+ * @param chipIndex index of the chip
+ */
+void LTC2620_SetDaisy(int cmd, int data, int dacaddr, int chipIndex);
+
+/**
+ * Sets a single chip (LTC2620_SetSingle) or multiple chip (LTC2620_SetDaisy)
+ * multiple chip is only for ctb where the multiple chips are connected in daisy fashion
+ * @param cmd command to send
+ * @param data dac value to be set
+ * @param dacaddr dac channel number for the chip
+ * @param chipIndex the chip to be set
+ */
+void LTC2620_Set(int cmd, int data, int dacaddr, int chipIndex);
+
+/**
+ * Configure (obtains dacaddr, command and ichip and calls LTC2620_Set)
+ */
+void LTC2620_Configure();
+
+/**
+ * Set Dac (obtains dacaddr, command and ichip and 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);

slsDetectorServers/slsDetectorServer/include/MAX1932.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <inttypes.h>
+
+/**
+ * Set Defines
+ * @param reg spi register
+ * @param cmsk chip select mask
+ * @param clkmsk clock output mask
+ * @param dmsk digital output mask
+ * @param dofst digital output offset
+ * @param minMV minimum voltage determined by hardware
+ * @param maxMV maximum voltage determined by hardware
+ */
+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
+ * @param val value to set
+ * @return OK or FAIL
+ */
+int MAX1932_Set (int val) ;
+
+
+

slsDetectorServers/slsDetectorServer/include/UDPPacketHeaderGenerator.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <inttypes.h>
+
+/** 
+ * Get current udp packet number 
+ */
+uint32_t getUDPPacketNumber();
+
+/** 
+ * Get current udp frame number 
+ */
+uint64_t getUDPFrameNumber();
+
+/**
+ * Called for each UDP packet header creation
+ * @param buffer pointer to header
+ * @param id module id
+ */
+void createUDPPacketHeader(char* buffer, uint16_t id);
+
+/** 
+ * fill up the udp packet with data till its full 
+ * @param buffer pointer to memory
+ */
+int fillUDPPacket(char* buffer);

slsDetectorServers/slsDetectorServer/include/blackfin.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <sys/types.h>
+#include <inttypes.h>
+
+/** I2C defines */
+#define I2C_CLOCK_MHZ   (131.25)
+
+/**
+ * Write into a 16 bit register
+ * @param offset address offset
+ * @param data 16 bit data
+ */
+void bus_w16(u_int32_t offset, u_int16_t data);
+
+/**
+ * Read from a 16 bit register
+ * @param offset address offset
+ * @retuns 16 bit data read
+ */
+u_int16_t bus_r16(u_int32_t offset);
+
+/**
+ * Write into a 32 bit register
+ * @param offset address offset
+ * @param data 32 bit data
+ */
+void bus_w(u_int32_t offset, u_int32_t data);
+
+/**
+ * Read from a 32 bit register
+ * @param offset address offset
+ * @retuns 32 bit data read
+ */
+u_int32_t bus_r(u_int32_t offset);
+
+/**
+ * Read from a 64 bit register
+ * @param aLSB LSB offset address
+ * @param aMSB MSB offset address
+ * @returns 64 bit data read
+ */
+int64_t get64BitReg(int aLSB, int aMSB);
+
+/**
+ * Write into a 64 bit register
+ * @param value 64 bit data
+ * @param aLSB LSB offset address
+ * @param aMSB MSB offset address
+ * @returns 64 bit data read
+ */
+int64_t set64BitReg(int64_t value, int aLSB, int aMSB);
+
+/**
+ * Read unsigned 64 bit from a 64 bit register
+ * @param aLSB LSB offset address
+ * @param aMSB MSB offset address
+ * @returns unsigned 64 bit data read
+ */
+uint64_t getU64BitReg(int aLSB, int aMSB);
+
+/**
+ * Write unsigned 64 bit into a 64 bit register
+ * @param value unsigned 64 bit data
+ * @param aLSB LSB offset address
+ * @param aMSB MSB offset address
+ */
+void setU64BitReg(uint64_t value, int aLSB, int aMSB);
+
+/**
+ * Read from a 32 bit register (literal register value provided by client)
+ * @param offset address offset
+ * @retuns 32 bit data read
+ */
+u_int32_t readRegister(u_int32_t offset);
+
+/**
+ * Write into a 32 bit register (literal register value provided by client)
+ * @param offset address offset
+ * @param data 32 bit data
+ */
+u_int32_t writeRegister(u_int32_t offset, u_int32_t data);
+
+/**
+ * Read from a 16 bit register (literal register value provided by client)
+ * @param offset address offset
+ * @retuns 16 bit data read
+ */
+u_int32_t readRegister16(u_int32_t offset);
+
+/**
+ * Write into a 16 bit register (literal register value provided by client)
+ * @param offset address offset
+ * @param data 16 bit data
+ */
+u_int32_t writeRegister16(u_int32_t offset, u_int32_t data);
+
+/**
+ * Get base address for memory copy
+ */
+uint64_t Blackfin_getBaseAddress();
+/**
+ * Map FPGA
+ */
+int mapCSP0(void);

slsDetectorServers/slsDetectorServer/include/clogger.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "ansi.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+
+#ifdef FIFODEBUG
+#define FILELOG_MAX_LEVEL logDEBUG5
+#elif VERYVERBOSE
+#define FILELOG_MAX_LEVEL logDEBUG4
+#elif VERBOSE
+#define FILELOG_MAX_LEVEL logDEBUG
+#elif DEBUG1
+#define FILELOG_MAX_LEVEL logDEBUG1
+#endif
+
+#ifndef FILELOG_MAX_LEVEL
+#define FILELOG_MAX_LEVEL logINFO
+#endif
+
+enum TLogLevel{
+logERROR, logWARNING, logINFOBLUE, logINFOGREEN, logINFORED, logINFO,
+logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, logDEBUG5
+};
+
+#define ERROR_MSG_LENGTH 1000
+
+#define FILE_LOG(lvl, fmt, ...) 				\
+	if (lvl > FILELOG_MAX_LEVEL);				\
+	else {char* temp = FILELOG_BuildLog fmt; FILELOG_PrintLog(lvl, temp);free(temp);}
+
+static inline void FILELOG_PrintLog(enum TLogLevel level, char* m) {
+	switch(level) {
+	case logERROR: 		cprintf(RED BOLD, "ERROR: %s", m);		break;
+	case logWARNING:	cprintf(YELLOW BOLD, "WARNING: %s", m);	break;
+	case logINFOBLUE: 	cprintf(BLUE, "INFO: %s", m);			break;
+	case logINFOGREEN:	cprintf(GREEN, "INFO: %s", m);			break;
+    case logINFORED:    cprintf(RED, "INFO: %s", m);            break;
+	case logINFO: 		cprintf(RESET, "INFO: %s", m);			break;
+	case logDEBUG: 		cprintf(MAGENTA, "DEBUG: %s", m);		break;
+	case logDEBUG1: 	cprintf(MAGENTA, "DEBUG1: %s", m);		break;
+	case logDEBUG2: 	cprintf(MAGENTA, "DEBUG2: %s", m);		break;
+	case logDEBUG3: 	cprintf(MAGENTA, "DEBUG3: %s", m);		break;
+	case logDEBUG4: 	cprintf(MAGENTA, "DEBUG4: %s", m);		break;
+	case logDEBUG5: 	cprintf(MAGENTA, "DEBUG5: %s", m);		break;
+	}
+}
+
+static inline char* FILELOG_BuildLog(const char* fmt, ...) {
+	char* p;
+	va_list ap;
+	p = malloc(ERROR_MSG_LENGTH);
+	va_start(ap, fmt);
+	int ret = vsnprintf(p, ERROR_MSG_LENGTH, fmt, ap);
+	va_end(ap);
+	if (ret < 0 || ret >= ERROR_MSG_LENGTH) {
+		FILELOG_PrintLog(logERROR, ("Could not print the "
+				"complete error message in the next print.\n"));
+	}
+	return p;
+};
+
+
+

slsDetectorServers/slsDetectorServer/include/common.h

@@ -0,0 +1,14 @@
+#pragma once
+
+/**
+ * Convert a value from a range to a different range (eg voltage to dac or vice versa)
+ * @param inputMin input minimum
+ * @param inputMax input maximum
+ * @param outputMin output minimum
+ * @param outputMax output maximum
+ * @param inputValue input value
+ * @param outputValue pointer to output value
+ * @returns FAIL if input value is out of bounds, else OK
+ */
+int ConvertToDifferentRange(int inputMin, int inputMax, int outputMin, int outputMax,
+        int inputValue, int* outputValue);

slsDetectorServers/slsDetectorServer/include/commonServerFunctions.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <inttypes.h>
+
+void SPIChipSelect (uint32_t* valw, uint32_t addr,  uint32_t csmask, uint32_t clkmask, uint32_t digoutmask, int convBit);
+
+void SPIChipDeselect (uint32_t* valw, uint32_t addr,  uint32_t csmask, uint32_t clkmask, uint32_t digoutmask, int convBit);
+
+void sendDataToSPI (uint32_t* valw, uint32_t addr, uint32_t val, int numbitstosend, uint32_t clkmask, uint32_t digoutmask, int digofset);
+
+uint32_t receiveDataFromSPI (uint32_t* valw, uint32_t addr, int numbitstoreceive, uint32_t clkmask, uint32_t readaddr) ;
+
+void serializeToSPI(uint32_t addr, uint32_t val, uint32_t csmask, int numbitstosend, uint32_t clkmask, uint32_t digoutmask, int digofset, int convBit);
+
+uint32_t serializeFromSPI(uint32_t addr, uint32_t csmask, int numbitstoreceive, uint32_t clkmask, uint32_t digoutmask, uint32_t readaddr, int convBit);

slsDetectorServers/slsDetectorServer/include/communication_funcs.h

@@ -0,0 +1,71 @@
+#ifndef COMMUNICATION_FUNCS_H
+#define COMMUNICATION_FUNCS_H
+
+
+#include "sls_detector_defs.h"
+
+typedef enum{
+	INT16,
+	INT32,
+	INT64,
+	OTHER
+}intType;
+
+
+int bindSocket(unsigned short int port_number);
+int acceptConnection(int socketDescriptor);
+void closeConnection(int file_Des);
+void exitServer(int socketDescriptor);
+
+void swapData(void* val,int length,intType itype);
+int sendData(int file_des, void* buf,int length, intType itype);
+int receiveData(int file_des, void* buf,int length, intType itype);
+int sendDataOnly(int file_des, void* buf,int length);
+int receiveDataOnly(int file_des, void* buf,int length);
+
+int sendModule(int file_des, sls_detector_module *myMod);
+int receiveModule(int file_des, sls_detector_module* myMod);
+
+/**
+ * Servers sets and prints error message for locked server
+ * @returns success of operaton
+ */
+void Server_LockedError();
+
+
+/**
+ * Server verifies if it is unlocked,
+ * sets and prints appropriate message if it is locked and different clients
+ * @returns success of operaton
+ */
+int Server_VerifyLock();
+
+
+/**
+ * Server sends result to client (also set ret to force_update if different clients)
+ * @param fileDes file descriptor for the socket
+ * @param itype 32 or 64 or others to determine to swap data from big endian to little endian
+ * @param update 1 if one must update if different clients, else 0
+ * @param retval pointer to result
+ * @param retvalSize size of result
+ * @returns result of operation
+ */
+int Server_SendResult(int fileDes, intType itype, int update, void* retval, int retvalSize);
+
+/**
+ * Convert mac address from integer to char array
+ * @param cmac char arrary result
+ * @param size size of char array result
+ * @param mac mac address as an integer
+ */
+void getMacAddressinString(char* cmac, int size, uint64_t mac);
+
+/**
+ * Convert ip address from integer to char array
+ * @param cip char arrary result
+ * @param ip ip address as an integer
+ */
+void getIpAddressinString(char* cip, uint32_t ip);
+
+
+#endif

slsDetectorServers/slsDetectorServer/include/communication_funcs_UDP.h

@@ -0,0 +1,34 @@
+#pragma once
+/**
+ * Get UDP socket desicriptor
+ * @param udp port index
+ */
+int getUdPSocketDescriptor(int index);
+
+/**
+ * Set udp destination
+ * @param index udp port index
+ * @param ip udp destination ip
+ * @param port udp destination port
+ */
+int setUDPDestinationDetails(int index, const char* ip, unsigned short int port);
+
+/**
+ * Create udp socket
+ * @param index udp port index
+ */
+int createUDPSocket(int index);
+
+/**
+ * Writes to socket file descriptor
+ * @param index udp port index
+ * @param buf pointer to memory to write
+ * @param length length of buffer to write to socket
+ */
+int sendUDPPacket(int index, const char* buf, int length);
+
+/**
+ * Close udp socket
+ * @index udp port index
+ */
+void closeUDPSocket(int index);

slsDetectorServers/slsDetectorServer/include/programfpga.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <stdio.h>
+
+/**
+ * Define GPIO pins if not defined
+ */
+void defineGPIOpins();
+
+/**
+ * Notify FPGA to not touch flash
+ */
+void FPGAdontTouchFlash();
+
+/**
+ * Notify FPGA to program from flash
+ */
+void FPGATouchFlash();
+
+/**
+ * Reset FPGA
+ */
+void resetFPGA();
+
+/**
+ * Erasing flash
+ */
+void eraseFlash();
+
+/**
+ * Open the drive to copy program and
+ * notify FPGA not to touch the program
+ * @param filefp pointer to flash
+ * @return 0 for success, 1 for fail (cannot open file for writing program)
+ */
+int startWritingFPGAprogram(FILE** filefp);
+
+/**
+ * When done writing the program, close file pointer and
+ * notify FPGA to pick up the program from flash
+ * @param filefp pointer to flash
+ */
+void stopWritingFPGAprogram(FILE* filefp);
+
+/**
+ * Write FPGA Program to flash
+ * @param fpgasrc source program
+ * @param fsize size of program
+ * @param filefp pointer to flash
+ * @return 0 for success, 1 for fail (cannot write)
+ */
+int writeFPGAProgram(char* fpgasrc, size_t fsize, FILE* filefp);

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -0,0 +1,408 @@
+#include "sls_detector_defs.h"
+#include "slsDetectorServer_defs.h" // DAC_INDEX, ADC_INDEX, also include RegisterDefs.h
+#ifdef GOTTHARDD
+#include "clogger.h"                 // runState(enum TLogLevel)
+#endif
+#include <stdlib.h>
+#include <stdio.h>					// FILE
+#include <sys/types.h>
+
+/****************************************************
+This functions are used by the slsDetectroServer_funcs interface.
+Here are the definitions, but the actual implementation should be done for each single detector.
+
+****************************************************/
+
+enum interfaceType {OUTER, INNER};
+
+// basic tests
+int			isFirmwareCheckDone();
+int			getFirmwareCheckResult(char** mess);
+void 		basictests();
+#if defined(GOTTHARDD) || defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
+int 		checkType();
+int 		testFpga();
+int 		testBus();
+#endif
+
+#ifdef GOTTHARDD
+int         detectorTest(enum digitalTestMode arg,  int ival);
+int 		testImage(int ival);
+#elif defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
+int 		detectorTest(enum digitalTestMode arg);
+#endif
+
+// Ids
+int64_t 	getDetectorId(enum idMode arg);
+u_int64_t  	getFirmwareVersion();
+u_int64_t   getFirmwareAPIVersion();
+#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
+u_int16_t 	getHardwareVersionNumber();
+u_int16_t 	getHardwareSerialNumber();
+#endif
+#ifdef JUNGFRAUD
+int			isHardwareVersion2();
+#endif
+u_int32_t	getDetectorNumber();
+u_int64_t  	getDetectorMAC();
+u_int32_t  	getDetectorIP();
+#ifdef GOTTHARDD
+u_int32_t   getBoardRevision();
+#endif
+
+
+// initialization
+void 		initControlServer();
+void		initStopServer();
+#ifdef EIGERD
+void 		getModuleConfiguration();
+#endif
+
+// set up detector
+#ifdef EIGERD
+void		allocateDetectorStructureMemory();
+#endif
+void 		setupDetector();
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+int         allocateRAM();
+void        updateDataBytes();
+#endif
+
+#if defined(GOTTHARDD) || defined(JUNGFRAUD)
+int			setDefaultDacs();
+#endif
+
+
+// advanced read/write reg
+#ifdef EIGERD
+int			writeRegister(uint32_t offset, uint32_t data);
+int  		readRegister(uint32_t offset, uint32_t* retval);
+#elif GOTTHARDD
+uint32_t    writeRegister16And32(uint32_t offset, uint32_t data); //FIXME its not there in ctb or moench?
+uint32_t    readRegister16And32(uint32_t offset);
+#else
+extern u_int32_t    writeRegister(u_int32_t offset, u_int32_t data);    // blackfin.h
+extern u_int32_t    readRegister(u_int32_t offset);                     // blackfin.h
+#endif
+
+
+// firmware functions (resets)
+#ifdef JUNGFRAUD
+void 		cleanFifos();
+void 		resetCore();
+void 		resetPeripheral();
+#elif GOTTHARDD
+void        setPhaseShiftOnce();
+void        setPhaseShift(int numphaseshift);
+void        cleanFifos();
+void        setADCSyncRegister();
+void        setDAQRegister();
+void        setChipOfInterestRegister(int adc);
+void        setROIADC(int adc);
+void        setGbitReadout();
+int         readConfigFile();
+void        setMasterSlaveConfiguration();
+#elif CHIPTESTBOARDD
+void        cleanFifos();
+void        resetCore();
+void        resetPeripheral();
+#elif MOENCHD
+void        cleanFifos();
+void        resetCore();
+void        resetPeripheral();
+#endif
+
+// parameters - dr, roi
+int 		setDynamicRange(int dr);
+#ifdef GOTTHARDD
+int 		setROI(ROI arg);
+ROI			getROI();
+#endif
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+int 		setADCEnableMask(uint32_t mask);
+uint32_t 	getADCEnableMask();
+void 		setADCInvertRegister(uint32_t val);
+uint32_t 	getADCInvertRegister();
+int			setExternalSamplingSource(int val);
+int			setExternalSampling(int val);
+#endif
+
+// parameters - readout
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(JUNGFRAUD)
+void 		setSpeed(enum speedVariable ind, int val, int mode);
+int         getSpeed(enum speedVariable ind, int mode);
+#else
+#ifndef GOTTHARD2D
+void 		setSpeed(enum speedVariable ind, int val);
+int         getSpeed(enum speedVariable ind);
+#endif
+#endif
+
+#if defined(EIGERD) || defined(CHIPTESTBOARDD)
+enum 		readOutFlags setReadOutFlags(enum readOutFlags val);
+#endif
+
+// parameters - timer
+#ifdef JUNGFRAUD
+int         selectStoragecellStart(int pos);
+#endif
+#if defined(JUNGFRAUD) || defined(EIGERD) 
+int 		setStartingFrameNumber(uint64_t value);
+int			getStartingFrameNumber(uint64_t* value);
+#endif
+int64_t 	setTimer(enum timerIndex ind, int64_t val);
+int64_t 	getTimeLeft(enum timerIndex ind);
+#if defined(JUNGFRAUD) || defined(GOTTHARDD) || defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D) || defined(GOTTHARD2D)
+int         validateTimer(enum timerIndex ind, int64_t val, int64_t retval);
+#endif
+
+// parameters - module, settings
+#if (!defined(CHIPTESTBOARDD)) && (!defined(MOENCHD)) && (!defined(MYTHEN3D)) && (!defined(GOTTHARD2D))
+int 		setModule(sls_detector_module myMod, char* mess);
+int 		getModule(sls_detector_module *myMod);
+enum 		detectorSettings setSettings(enum detectorSettings sett);
+#endif
+#if !defined(MYTHEN3D) && !defined(GOTTHARD2D)
+enum 		detectorSettings getSettings();
+#endif
+
+// parameters - threshold
+#ifdef EIGERD
+int 		getThresholdEnergy();
+int 		setThresholdEnergy(int ev);
+#endif
+
+// parameters - dac, adc, hv
+#ifdef GOTTHARDD
+extern void AD9252_Set(int addr, int val);      // AD9252.h (old board)
+#endif
+#if defined(GOTTHARDD) || defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
+extern void AD9257_Set(int addr, int val);      // AD9257.h
+#endif
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+extern int AD9257_GetVrefVoltage(int mV);                  // AD9257.h
+extern int AD9257_SetVrefVoltage(int val, int mV);   // AD9257.h
+#endif
+
+#if (!defined(MYTHEN3D)) && (!defined(GOTTHARD2D))
+void 		setDAC(enum DACINDEX ind, int val, int mV);
+int         getDAC(enum DACINDEX ind, int mV);
+int         getMaxDacSteps();
+#endif
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+int         dacToVoltage(int dac);
+int         checkVLimitCompliant(int mV);
+int         checkVLimitDacCompliant(int dac);
+int         getVLimit();
+void        setVLimit(int l);
+#endif
+
+#ifdef CHIPTESTBOARDD
+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);
+void        powerOff();
+#endif
+
+#ifndef MOENCHD
+#if !defined(MYTHEN3D) && !defined(GOTTHARD2D)
+int 		getADC(enum ADCINDEX ind);
+#endif
+#endif
+#if !defined(MYTHEN3D) && !defined(GOTTHARD2D)
+int 		setHighVoltage(int val);
+#endif
+
+
+// parameters - timing, extsig
+#if !defined(MYTHEN3D) && !defined(GOTTHARD2D)
+void 		setTiming( enum timingMode arg);
+enum 		timingMode getTiming();
+#endif
+#ifdef GOTTHARDD
+void        setExtSignal(enum externalSignalFlag  mode);
+int         getExtSignal();
+#endif
+
+// configure mac
+#ifdef GOTTHARDD
+void        calcChecksum(mac_conf* mac, int sourceip, int destip);
+#elif JUNGFRAUD
+void setNumberofUDPInterfaces(int val);
+int getNumberofUDPInterfaces();
+void selectPrimaryInterface(int val);
+int getPrimaryInterface();
+void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip, uint64_t destmac, uint32_t destport, uint64_t sourcemac, uint32_t sourceip, uint32_t sourceport);
+void calcChecksum(udp_header* udp);
+#endif
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+long int 	calcChecksum(int sourceip, int destip);
+#endif
+#ifdef GOTTHARDD
+int         getAdcConfigured();
+#endif
+
+#ifdef EIGERD
+int 		configureMAC(uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t sourceip, uint32_t udpport, uint32_t udpport2);
+#elif JUNGFRAUD
+int 		configureMAC(int numInterfaces, int selInterface,
+				uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t sourceip, uint32_t udpport,
+				uint32_t destip2, uint64_t destmac2, uint64_t sourcemac2, uint32_t sourceip2, uint32_t udpport2);
+#else
+int 		configureMAC(uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t sourceip, uint32_t udpport);
+#endif
+
+#if defined(JUNGFRAUD) || defined(EIGERD)
+int 		setDetectorPosition(int pos[]);
+#endif
+#ifdef EIGERD
+int			setQuad(int value);
+int			getQuad();
+int			setInterruptSubframe(int value);
+int			getInterruptSubframe();
+int 		setReadNLines(int value);
+int			getReadNLines();
+#endif
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(EIGERD)
+int 		enableTenGigabitEthernet(int val);
+#endif
+
+
+// very detector specific
+
+// moench specific - powerchip
+#ifdef MOENCHD
+int         powerChip (int on);
+#endif
+
+// chip test board or moench specific - configure frequency, phase, pll, flashing firmware
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+void        configurePhase(enum CLKINDEX ind, int val, int degrees);
+int         getPhase(enum CLKINDEX ind, int degrees);
+int         getMaxPhase(enum CLKINDEX ind);
+int 		validatePhaseinDegrees(enum speedVariable ind, int val, int retval);
+void        configureFrequency(enum CLKINDEX ind, int val);
+int         getFrequency(enum CLKINDEX ind);
+void        configureSyncFrequency(enum CLKINDEX ind);
+void        setAdcOffsetRegister(int adc, int val);
+int         getAdcOffsetRegister(int adc);
+extern void eraseFlash();                                                   // programfpga.h
+extern int  startWritingFPGAprogram(FILE** filefp);                         // programfpga.h
+extern void stopWritingFPGAprogram(FILE* filefp);                           // programfpga.h
+extern int  writeFPGAProgram(char* fpgasrc, size_t fsize, FILE* filefp);    // programfpga.h
+// patterns
+uint64_t    writePatternIOControl(uint64_t word);
+uint64_t    writePatternClkControl(uint64_t word);
+uint64_t    readPatternWord(int addr);
+uint64_t    writePatternWord(int addr, uint64_t word);
+int         setPatternWaitAddress(int level, int addr);
+uint64_t    setPatternWaitTime(int level, uint64_t t);
+void        setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop);
+int			setLEDEnable(int enable);
+void		setDigitalIODelay(uint64_t pinMask, int delay);
+void 		setPatternMask(uint64_t mask);
+uint64_t	getPatternMask();
+void 		setPatternBitMask(uint64_t mask);
+uint64_t	getPatternBitMask();
+#endif
+
+// jungfrau specific - powerchip, autocompdisable, clockdiv, asictimer, clock, pll, flashing firmware
+#ifdef JUNGFRAUD
+void 		initReadoutConfiguration();
+int         powerChip (int on);
+int         autoCompDisable(int on);
+void        configureASICTimer();
+void        setClockDivider(int val);
+int         getClockDivider();
+void        setAdcPhase(int val, int degrees);
+int         getPhase(int degrees);
+int			getMaxPhaseShift();
+int 		validatePhaseinDegrees(int val, int retval);
+int         setThresholdTemperature(int val);
+int         setTemperatureControl(int val);
+int         setTemperatureEvent(int val);
+extern void eraseFlash();													// programfpga.h
+extern int 	startWritingFPGAprogram(FILE** filefp);							// programfpga.h
+extern void stopWritingFPGAprogram(FILE* filefp);							// programfpga.h
+extern int 	writeFPGAProgram(char* fpgasrc, size_t fsize, FILE* filefp);	// programfpga.h
+void		alignDeserializer();
+
+// eiger specific - iodelay, pulse, rate, temp, activate, delay nw parameter
+#elif EIGERD
+int 		setIODelay(int val);
+int 		setCounterBit(int val);
+int 		pulsePixel(int n, int x, int y);
+int 		pulsePixelNMove(int n, int x, int y);
+int 		pulseChip(int n);
+int64_t 	setRateCorrection(int64_t custom_tau_in_nsec);
+int 		getRateCorrectionEnable();
+int 		getDefaultSettingsTau_in_nsec();
+void 		setDefaultSettingsTau_in_nsec(int t);
+int64_t 	getCurrentTau();
+void 		setExternalGating(int enable[]);
+int 		setAllTrimbits(int val);
+int 		getAllTrimbits();
+int 		getBebFPGATemp();
+int 		activate(int enable);
+#endif
+
+#if defined(JUNGFRAUD) || defined(EIGERD)
+int         setNetworkParameter(enum NETWORKINDEX mode, int value);
+#endif
+
+
+
+
+// aquisition
+#ifdef EIGERD
+int 		prepareAcquisition();
+#endif
+int 		startStateMachine();
+#ifdef VIRTUAL
+void* start_timer(void* arg);
+#endif
+int 		stopStateMachine();
+#ifdef EIGERD
+int			softwareTrigger();
+#endif
+
+#ifdef EIGERD
+int 		startReadOut();
+#endif
+enum 		runStatus getRunStatus();
+void 		readFrame(int *ret, char *mess);
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
+void 		readandSendUDPFrames(int *ret, char *mess);
+void        unsetFifoReadStrobes();
+void        readSample(int ns);
+uint32_t	checkDataInFifo();
+int         checkFifoForEndOfAcquisition();
+int         readFrameFromFifo();
+#endif
+
+#if defined(GOTTHARDD) || defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D) || defined(GOTTHARD2D)
+u_int32_t 	runBusy();
+#endif
+
+#ifdef GOTTHARDD
+u_int32_t   runState(enum TLogLevel lev);
+#endif
+
+
+//common
+#ifdef EIGERD
+int 		copyModule(sls_detector_module *destMod, sls_detector_module *srcMod);
+#endif
+int 		calculateDataBytes();
+int 		getTotalNumberOfChannels();
+int 		getNumberOfChips();
+int 		getNumberOfDACs();
+int 		getNumberOfChannelsPerChip();
+
+

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -0,0 +1,111 @@
+#pragma once
+#include "sls_detector_defs.h"
+#include "clogger.h"
+
+enum numberMode {DEC, HEX};
+#define GOODBYE 					(-200)
+#define REBOOT						(-400)
+
+// initialization functions
+int printSocketReadError();
+void init_detector();
+int decode_function(int);
+const char* getRetName();
+const char* getTimerName(enum timerIndex ind);
+const char* getSpeedName(enum speedVariable ind);
+const char* getFunctionName(enum detFuncs func);
+void function_table();
+void functionNotImplemented();
+void modeNotImplemented(char* modename, int mode);
+void validate(int arg, int retval, char* modename, enum numberMode nummode);
+void validate64(int64_t arg, int64_t retval, char* modename, enum numberMode nummode);
+int executeCommand(char* command, char* result, enum TLogLevel level);
+int M_nofunc(int);
+int M_nofuncMode(int);
+
+// functions called by client
+int exec_command(int);
+int get_detector_type(int);
+int set_external_signal_flag(int);
+int set_timing_mode(int);
+int get_id(int);
+int digital_test(int);
+int set_dac(int);
+int get_adc(int);
+int write_register(int);
+int read_register(int);
+int set_module(int);
+int get_module(int);
+int set_settings(int);
+int get_threshold_energy(int);
+int start_acquisition(int);
+int stop_acquisition(int);
+int start_readout(int);
+int get_run_status(int);
+int start_and_read_all(int);
+int read_all(int);
+int set_timer(int);
+int get_time_left(int);
+int set_dynamic_range(int);
+int set_readout_flags(int);
+int set_roi(int);
+int get_roi(int);
+int set_speed(int);
+int exit_server(int);
+int lock_server(int);
+int get_last_client_ip(int);
+int set_port(int);
+int update_client(int);
+int send_update(int);
+int configure_mac(int);
+int calibrate_pedestal(int);
+int enable_ten_giga(int);
+int set_all_trimbits(int);
+int set_pattern_io_control(int);
+int set_pattern_clock_control(int);
+int set_pattern_word(int);
+int set_pattern_loop(int);
+int set_pattern_wait_addr(int);
+int set_pattern_wait_time(int);
+int set_pattern_mask(int);
+int get_pattern_mask(int);
+int set_pattern_bit_mask(int);
+int get_pattern_bit_mask(int);
+int write_adc_register(int);
+int set_counter_bit(int);
+int pulse_pixel(int);
+int pulse_pixel_and_move(int);
+int pulse_chip(int);
+int set_rate_correct(int);
+int get_rate_correct(int);
+int set_network_parameter(int);
+int program_fpga(int);
+int reset_fpga(int);
+int power_chip(int);
+int set_activate(int);
+int prepare_acquisition(int);
+int threshold_temp(int);
+int temp_control(int);
+int temp_event(int);
+int auto_comp_disable(int);
+int storage_cell_start(int);
+int check_version(int);
+int software_trigger(int);
+int led(int);
+int digital_io_delay(int);
+int copy_detector_server(int);
+int reboot_controller(int);
+int set_adc_enable_mask(int);
+int get_adc_enable_mask(int);
+int set_adc_invert(int);
+int get_adc_invert(int);
+int set_external_sampling_source(int);
+int set_external_sampling(int);
+int set_starting_frame_number(int);
+int get_starting_frame_number(int);
+int set_quad(int);
+int get_quad(int);
+int set_interrupt_subframe(int);
+int get_interrupt_subframe(int);
+int set_read_n_lines(int);
+int get_read_n_lines(int);