detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-23 18:17:59 +02:00
Code Issues Actions Packages Releases Activity

separated parameters and versions

Browse Source
This commit is contained in:
maliakal_d
2019-11-06 16:43:59 +01:00
parent 705ddb7f42
commit 18b8720c17
27 changed files with 872 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
View File

Binary file not shown.

42
slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
View File

@ -118,14 +118,14 @@ void basictests() {
uint16_t hsnumber = getHardwareSerialNumber();
uint32_t ipadd = getDetectorIP();
uint64_t macadd = getDetectorMAC();
int64_t fwversion = getDetectorId(DETECTOR_FIRMWARE_VERSION);
int64_t swversion = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t fwversion = getFirmwareVersion();
int64_t swversion = getServerVersion();
int64_t sw_fw_apiversion = 0;
int64_t client_sw_apiversion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t client_sw_apiversion = getClientServerAPIVersion();
if (fwversion >= MIN_REQRD_VRSN_T_RD_API)
sw_fw_apiversion = getDetectorId(SOFTWARE_FIRMWARE_API_VERSION);
sw_fw_apiversion = getFirmwareAPIVersion();
FILE_LOG(logINFOBLUE, ("************ Chip Test Board Server *********************\n"
"Hardware Version:\t\t 0x%x\n"
"Hardware Serial Nr:\t\t 0x%x\n"
@ -323,39 +323,15 @@ int testBus() {
return ret;
}
int detectorTest( enum digitalTestMode arg){
#ifdef VIRTUAL
return OK;
#endif
switch(arg){
case DETECTOR_FIRMWARE_TEST: return testFpga();
case DETECTOR_BUS_TEST: return testBus();
default:
FILE_LOG(logERROR, ("Test %s not implemented for this detector\n", (int)arg));
break;
}
return OK;
}
/* Ids */
int64_t getDetectorId(enum idMode arg){
int64_t retval = -1;
uint64_t getServerVersion() {
return APICTB;
}
switch(arg){
case DETECTOR_SERIAL_NUMBER:
return getDetectorNumber();
case DETECTOR_FIRMWARE_VERSION:
return getFirmwareVersion();
case SOFTWARE_FIRMWARE_API_VERSION:
return getFirmwareAPIVersion();
case DETECTOR_SOFTWARE_VERSION:
case CLIENT_SOFTWARE_API_VERSION:
return APICTB;
default:
return retval;
}
uint64_t getClientServerAPIVersion() {
return APICTB;
}
uint64_t getFirmwareVersion() {

171
slsDetectorServers/eigerDetectorServer/Beb.c
View File

@ -454,6 +454,146 @@ int Beb_Set32bitOverflow(int val) {
return valueread;
}
int Beb_GetTenGigaFlowControl() {
u_int32_t offset = FLOW_REG_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to get ten giga flow control. FAIL\n"));
return -1;
} else {
u_int32_t retval = Beb_Read32(csp0base, offset);
retval = (retval & FLOW_REG_TXM_FLOW_CNTRL_10G_MSK) >> FLOW_REG_TXM_FLOW_CNTRL_10G_OFST;
Beb_close(fd,csp0base);
return retval;
}
}
int Beb_SetTenGigaFlowControl(int value) {
FILE_LOG(logINFO, ("Setting ten giga flow control to %d\n", value));
value = value == 0 ? 0 : 1;
u_int32_t offset = FLOW_REG_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to set ten giga flow control. FAIL\n"));
return 0;
} else {
// reset bit
u_int32_t retval = Beb_Read32(csp0base, offset);
Beb_Write32(csp0base, offset,retval & ~FLOW_REG_TXM_FLOW_CNTRL_10G_MSK);
// set bit
retval = Beb_Read32(csp0base, offset);
Beb_Write32(csp0base, offset,retval |
((value << FLOW_REG_TXM_FLOW_CNTRL_10G_OFST) & FLOW_REG_TXM_FLOW_CNTRL_10G_MSK));
Beb_close(fd,csp0base);
return 1;
}
}
int Beb_GetTransmissionDelayFrame() {
u_int32_t offset = TXM_DELAY_FRAME_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to get transmission delay frame. FAIL\n"));
return -1;
} else {
u_int32_t retval = Beb_Read32(csp0base, offset);
Beb_close(fd,csp0base);
return retval;
}
}
int Beb_SetTransmissionDelayFrame(int value) {
FILE_LOG(logINFO, ("Setting transmission delay frame to %d\n", value));
if (value < 0) {
FILE_LOG(logERROR, ("Invalid transmission delay frame value %d\n", value));
return 0;
}
u_int32_t offset = TXM_DELAY_FRAME_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to set transmission delay frame. FAIL\n"));
return 0;
} else {
Beb_Write32(csp0base, offset, value);
Beb_close(fd,csp0base);
return 1;
}
}
int Beb_GetTransmissionDelayLeft() {
u_int32_t offset = TXM_DELAY_LEFT_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to get transmission delay left. FAIL\n"));
return -1;
} else {
u_int32_t retval = Beb_Read32(csp0base, offset);
Beb_close(fd,csp0base);
return retval;
}
}
int Beb_SetTransmissionDelayLeft(int value) {
FILE_LOG(logINFO, ("Setting transmission delay left to %d\n", value));
if (value < 0) {
FILE_LOG(logERROR, ("Invalid transmission delay left value %d\n", value));
return 0;
}
u_int32_t offset = TXM_DELAY_LEFT_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to set transmission delay left. FAIL\n"));
return 0;
} else {
Beb_Write32(csp0base, offset, value);
Beb_close(fd,csp0base);
return 1;
}
}
int Beb_GetTransmissionDelayRight() {
u_int32_t offset = TXM_DELAY_RIGHT_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to get transmission delay right. FAIL\n"));
return -1;
} else {
u_int32_t retval = Beb_Read32(csp0base, offset);
Beb_close(fd,csp0base);
return retval;
}
}
int Beb_SetTransmissionDelayRight(int value) {
FILE_LOG(logINFO, ("Setting transmission delay right to %d\n", value));
if (value < 0) {
FILE_LOG(logERROR, ("Invalid transmission delay right value %d\n", value));
return 0;
}
u_int32_t offset = TXM_DELAY_RIGHT_OFFSET;
u_int32_t* csp0base = 0;
int fd = Beb_open(&csp0base,XPAR_PLB_GPIO_SYS_BASEADDR);
if (fd <= 0) {
FILE_LOG(logERROR, ("Could not read register to set transmission delay right. FAIL\n"));
return 0;
} else {
Beb_Write32(csp0base, offset, value);
Beb_close(fd,csp0base);
return 1;
}
}
int Beb_SetNetworkParameter(enum NETWORKINDEX mode, int val) {
if (!Beb_activated)
@ -475,15 +615,8 @@ int Beb_SetNetworkParameter(enum NETWORKINDEX mode, int val) {
offset = TXM_DELAY_RIGHT_OFFSET;
strcpy(modename,"Transmission Delay Right");
break;
case TXN_FRAME:
offset = TXM_DELAY_FRAME_OFFSET;
strcpy(modename,"Transmission Delay Frame");
break;
case FLOWCTRL_10G:
offset = FLOW_REG_OFFSET;
strcpy(modename,"Flow Control for 10G");
if (val>0) val = 1;
break;
default: FILE_LOG(logERROR, ("Unrecognized mode in network parameter: %d\n",mode)); return -1;
}
//open file pointer
@ -491,31 +624,15 @@ int Beb_SetNetworkParameter(enum NETWORKINDEX mode, int val) {
if (fd < 0) {
FILE_LOG(logERROR, ("Could not read register to set network parameter. FAIL\n"));
return -1;
}
else {
} else {
if (val > -1) {
if (mode != FLOWCTRL_10G) {
valueread = Beb_Read32(csp0base, offset);
Beb_Write32(csp0base, offset,val);
}
// flow control reg has other bits for other control
else {
// reset bit
valueread = Beb_Read32(csp0base, offset);
Beb_Write32(csp0base, offset,valueread & ~FLOW_REG_TXM_FLOW_CNTRL_10G_MSK);
// set bit
valueread = Beb_Read32(csp0base, offset);
Beb_Write32(csp0base, offset,valueread |
((val << FLOW_REG_TXM_FLOW_CNTRL_10G_OFST) & FLOW_REG_TXM_FLOW_CNTRL_10G_MSK));
}
}
valueread = Beb_Read32(csp0base, offset);
if (mode == FLOWCTRL_10G)
valueread = (valueread & FLOW_REG_TXM_FLOW_CNTRL_10G_MSK) >> FLOW_REG_TXM_FLOW_CNTRL_10G_OFST;
}
//close file pointer

11
slsDetectorServers/eigerDetectorServer/Beb.h
View File

@ -41,7 +41,16 @@ int Beb_SetSlaveViaSoftware();
int Beb_Activate(int enable);
int Beb_GetActivate();
int Beb_Set32bitOverflow(int val);
int Beb_SetNetworkParameter(enum NETWORKINDEX mode, int val);
int Beb_GetTenGigaFlowControl();
int Beb_SetTenGigaFlowControl(int value);
int Beb_GetTransmissionDelayFrame();
int Beb_SetTransmissionDelayFrame(int value);
int Beb_GetTransmissionDelayLeft();
int Beb_SetTransmissionDelayLeft(int value);
int Beb_GetTransmissionDelayRight();
int Beb_SetTransmissionDelayRight(int value);
int Beb_ResetToHardwareSettings();
u_int32_t Beb_GetFirmwareRevision();
u_int32_t Beb_GetFirmwareSoftwareAPIVersion();

BIN
slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
View File

Binary file not shown.

140
slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -110,10 +110,10 @@ void basictests() {
#endif
uint32_t ipadd = getDetectorIP();
uint64_t macadd = getDetectorMAC();
int64_t fwversion = getDetectorId(DETECTOR_FIRMWARE_VERSION);
int64_t swversion = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t sw_fw_apiversion = getDetectorId(SOFTWARE_FIRMWARE_API_VERSION);
int64_t client_sw_apiversion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t fwversion = getFirmwareVersion();
int64_t swversion = getServerVersion();
int64_t sw_fw_apiversion = getFirmwareAPIVersion();
int64_t client_sw_apiversion = getClientServerAPIVersion();
FILE_LOG(logINFOBLUE, ("**************** EIGER Server *********************\n\n"
"Detector IP Addr:\t\t 0x%x\n"
@ -190,26 +190,12 @@ void basictests() {
/* Ids */
int64_t getDetectorId(enum idMode arg) {
int64_t retval = -1;
switch(arg) {
case DETECTOR_SERIAL_NUMBER:
retval = getDetectorNumber();/** to be implemented with mac? */
break;
case DETECTOR_FIRMWARE_VERSION:
return (int64_t)getFirmwareVersion();
case SOFTWARE_FIRMWARE_API_VERSION:
return (int64_t)getFirmwareAPIVersion();
case DETECTOR_SOFTWARE_VERSION:
case CLIENT_SOFTWARE_API_VERSION:
return APIEIGER;
default:
break;
}
return retval;
uint64_t getServerVersion() {
return APIEIGER;
}
uint64_t getClientServerAPIVersion() {
return APIEIGER;
}
u_int64_t getFirmwareVersion() {
@ -1347,6 +1333,7 @@ int setClockDivider(enum CLKINDEX ind, int val) {
#endif
eiger_readoutspeed = val;
}
return OK;
}
int getClockDivider(enum CLKINDEX ind) {
@ -1600,44 +1587,83 @@ int activate(int enable) {
#endif
}
int setNetworkParameter(enum NETWORKINDEX mode, int value) {
#ifndef VIRTUAL
return Beb_SetNetworkParameter(mode, value);
int getTenGigaFlowControl() {
#ifdef VIRTUAL
return eiger_virtual_transmission_flowcontrol_10g;
#else
if (value>-1) {
switch(mode) {
case TXN_LEFT:
eiger_virtual_transmission_delay_left = value;
break;
case TXN_RIGHT:
eiger_virtual_transmission_delay_right = value;
break;
case TXN_FRAME:
eiger_virtual_transmission_delay_frame = value;
break;
case FLOWCTRL_10G:
eiger_virtual_transmission_flowcontrol_10g = value;
if (value>0) value = 1;
break;
default: FILE_LOG(logERROR, ("Unrecognized mode in network parameter: %d\n",mode));
return -1;
}
}
switch(mode) {
case TXN_LEFT:
return eiger_virtual_transmission_delay_left;
case TXN_RIGHT:
return eiger_virtual_transmission_delay_right;
case TXN_FRAME:
return eiger_virtual_transmission_delay_frame;
case FLOWCTRL_10G:
return eiger_virtual_transmission_flowcontrol_10g;
default: FILE_LOG(logERROR, ("Unrecognized mode in network parameter: %d\n",mode));
return -1;
}
return Beb_GetTenGigaFlowControl();
#endif
}
int setTenGigaFlowControl(int value) {
#ifdef VIRTUAL
eiger_virtual_transmission_flowcontrol_10g = (value == 0? 0 : 1);
#else
if (!Beb_SetTenGigaFlowControl(value)) {
return FAIL;
}
#endif
return OK;
}
int getTransmissionDelayFrame() {
#ifdef VIRTUAL
return eiger_virtual_transmission_delay_frame;
#else
return Beb_GetTransmissionDelayFrame();
#endif
}
int setTransmissionDelayFrame(int value) {
#ifdef VIRTUAL
eiger_virtual_transmission_delay_frame = value;
#else
if (!Beb_SetTransmissionDelayFrame(value)) {
return FAIL;
}
#endif
return OK;
}
int getTransmissionDelayLeft() {
#ifdef VIRTUAL
return eiger_virtual_transmission_delay_left;
#else
return Beb_GetTransmissionDelayLeft();
#endif
}
int setTransmissionDelayLeft(int value) {
#ifdef VIRTUAL
eiger_virtual_transmission_delay_left = value;
#else
if (!Beb_SetTransmissionDelayLeft(value)) {
return FAIL;
}
#endif
return OK;
}
int getTransmissionDelayRight() {
#ifdef VIRTUAL
return eiger_virtual_transmission_delay_right;
#else
return Beb_GetTransmissionDelayRight();
#endif
}
int setTransmissionDelayRight(int value) {
#ifdef VIRTUAL
eiger_virtual_transmission_delay_right = value;
#else
if (!Beb_SetTransmissionDelayRight(value)) {
return FAIL;
}
#endif
return OK;
}

BIN
slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
View File

Binary file not shown.

30
slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
View File

@ -78,7 +78,7 @@ void basictests() {
// does check only if flag is 0 (by default), set by command line
if ((!debugflag) && ((testFpga() == FAIL) || (testBus() == FAIL))) {
sprintf(firmware_message,
"Could not pass basic tests of FPGA and bus. Dangerous to continue. (Firmware version:0x%llx) \n", getDetectorId(DETECTOR_FIRMWARE_VERSION));
"Could not pass basic tests of FPGA and bus. Dangerous to continue. (Firmware version:0x%llx) \n", getFirmwareVersion());
FILE_LOG(logERROR, ("%s\n\n", firmware_message));
firmware_compatibility = FAIL;
firmware_check_done = 1;
@ -88,10 +88,10 @@ void basictests() {
uint16_t hversion = getHardwareVersionNumber();
uint32_t ipadd = getDetectorIP();
uint64_t macadd = getDetectorMAC();
int64_t fwversion = getDetectorId(DETECTOR_FIRMWARE_VERSION);
int64_t swversion = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t sw_fw_apiversion = getDetectorId(SOFTWARE_FIRMWARE_API_VERSION);
int64_t client_sw_apiversion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t fwversion = getFirmwareVersion();
int64_t swversion = getServerVersion();
int64_t sw_fw_apiversion = getFirmwareAPIVersion();
int64_t client_sw_apiversion = getClientServerAPIVersion();
uint32_t requiredFirmwareVersion = REQRD_FRMWRE_VRSN;
FILE_LOG(logINFOBLUE, ("************ Gotthard2 Server *********************\n"
@ -223,22 +223,12 @@ int testBus() {
/* Ids */
int64_t getDetectorId(enum idMode arg){
int64_t retval = -1;
uint64_t getServerVersion() {
return APIGOTTHARD2;
}
switch(arg){
case DETECTOR_SERIAL_NUMBER:
return getDetectorNumber();// or getDetectorMAC()
case DETECTOR_FIRMWARE_VERSION:
return getFirmwareVersion();
case SOFTWARE_FIRMWARE_API_VERSION:
return getFirmwareAPIVersion();
case DETECTOR_SOFTWARE_VERSION:
case CLIENT_SOFTWARE_API_VERSION:
return APIGOTTHARD2;
default:
return retval;
}
uint64_t getClientServerAPIVersion() {
return APIGOTTHARD2;
}
u_int64_t getFirmwareVersion() {

BIN
slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
View File

Binary file not shown.

53
slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c
View File

@ -101,9 +101,9 @@ void basictests() {
uint32_t boardrev = getBoardRevision();
uint32_t ipadd = getDetectorIP();
uint64_t macadd = getDetectorMAC();
int64_t fwversion = getDetectorId(DETECTOR_FIRMWARE_VERSION);
int64_t swversion = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t client_sw_apiversion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t fwversion = getFirmwareVersion();
int64_t swversion = getServerVersion();
int64_t client_sw_apiversion = getClientServerAPIVersion();
FILE_LOG(logINFOBLUE, ("************ Gotthard Server *********************\n"
"Board Revision : 0x%x\n"
@ -243,51 +243,32 @@ int testBus() {
return ret;
}
int detectorTest( enum digitalTestMode arg, int ival) {
#ifdef VIRTUAL
return OK;
#endif
switch(arg){
case IMAGE_TEST: return testImage(ival);
case DETECTOR_FIRMWARE_TEST: return testFpga();
case DETECTOR_BUS_TEST: return testBus();
default:
FILE_LOG(logERROR, ("Test not implemented for this detector %d\n", (int)arg));
break;
}
return OK;
}
int testImage(int ival) {
void setTestImageMode(int ival) {
uint32_t addr = MULTI_PURPOSE_REG;
if (ival >= 0) {
if (ival == 0) {
FILE_LOG(logINFO, ("Switching on Image Test\n"));
FILE_LOG(logINFO, ("Switching on Image Test Mode\n"));
bus_w (addr, bus_r(addr) & ~DGTL_TST_MSK);
} else {
FILE_LOG(logINFO, ("Switching off Image Test\n"));
FILE_LOG(logINFO, ("Switching off Image Test Mode\n"));
bus_w (addr, bus_r(addr) | DGTL_TST_MSK);
}
}
return ((bus_r(addr) & DGTL_TST_MSK) >> DGTL_TST_OFST);
}
int getTestImageMode() {
return ((bus_r(MULTI_PURPOSE_REG) & DGTL_TST_MSK) >> DGTL_TST_OFST);
}
/* Ids */
int64_t getDetectorId(enum idMode arg){
int64_t retval = -1;
uint64_t getServerVersion() {
return APIGOTTHARD;
}
switch(arg){
case DETECTOR_SERIAL_NUMBER:
return getDetectorNumber();
case DETECTOR_FIRMWARE_VERSION:
return getFirmwareVersion();
case DETECTOR_SOFTWARE_VERSION:
case CLIENT_SOFTWARE_API_VERSION:
return APIGOTTHARD;
default:
return retval;
}
uint64_t getClientServerAPIVersion() {
return APIGOTTHARD;
}
u_int64_t getFirmwareVersion() {
@ -426,6 +407,9 @@ void setupDetector() {
setPeriod(DEFAULT_PERIOD);
setDelayAfterTrigger(DEFAULT_DELAY);
cleanFifos();
}
int setDefaultDacs() {
@ -1509,6 +1493,7 @@ int setPhase(enum CLKINDEX ind, int val, int degrees) {
return FAIL;
}
setPhaseShift(val);
return OK;
}
/* aquisition */

BIN
slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
View File

Binary file not shown.

118
slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c
View File

@ -95,15 +95,15 @@ void basictests() {
uint16_t hsnumber = getHardwareSerialNumber();
uint32_t ipadd = getDetectorIP();
uint64_t macadd = getDetectorMAC();
int64_t fwversion = getDetectorId(DETECTOR_FIRMWARE_VERSION);
int64_t swversion = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t fwversion = getFirmwareVersion();
int64_t swversion = getServerVersion();
int64_t sw_fw_apiversion = 0;
int64_t client_sw_apiversion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t client_sw_apiversion = getClientServerAPIVersion();
uint32_t requiredFirmwareVersion = (isHardwareVersion2() ? REQRD_FRMWRE_VRSN_BOARD2 : REQRD_FRMWRE_VRSN);
if (fwversion >= MIN_REQRD_VRSN_T_RD_API)
sw_fw_apiversion = getDetectorId(SOFTWARE_FIRMWARE_API_VERSION);
sw_fw_apiversion = getFirmwareAPIVersion();
FILE_LOG(logINFOBLUE, ("************ Jungfrau Server *********************\n"
"Hardware Version:\t\t 0x%x\n"
"Hardware Serial Nr:\t\t 0x%x\n"
@ -240,44 +240,15 @@ int testBus() {
int detectorTest( enum digitalTestMode arg){
#ifdef VIRTUAL
return OK;
#endif
switch(arg){
case DETECTOR_FIRMWARE_TEST: return testFpga();
case DETECTOR_BUS_TEST: return testBus();
//DETECTOR_MEMORY_TEST:testRAM
//DETECTOR_SOFTWARE_TEST:
default:
FILE_LOG(logERROR, ("Test %s not implemented for this detector\n", (int)arg));
break;
}
return OK;
}
/* Ids */
int64_t getDetectorId(enum idMode arg){
int64_t retval = -1;
uint64_t getServerVersion() {
return APIJUNGFRAU;
}
switch(arg){
case DETECTOR_SERIAL_NUMBER:
return getDetectorNumber();// or getDetectorMAC()
case DETECTOR_FIRMWARE_VERSION:
return getFirmwareVersion();
case SOFTWARE_FIRMWARE_API_VERSION:
return getFirmwareAPIVersion();
case DETECTOR_SOFTWARE_VERSION:
case CLIENT_SOFTWARE_API_VERSION:
return APIJUNGFRAU;
default:
return retval;
}
uint64_t getClientServerAPIVersion() {
return APIJUNGFRAU;
}
u_int64_t getFirmwareVersion() {
@ -1593,45 +1564,44 @@ void alignDeserializer() {
bus_w(ADC_DSRLZR_3_REG, bus_r(ADC_DSRLZR_3_REG) & (~(ADC_DSRLZR_3_RFRSH_ALGNMNT_MSK)));
}
int setNetworkParameter(enum NETWORKINDEX mode, int value) {
switch(mode) {
case TXN_FRAME:
if (value >= 0) {
FILE_LOG(logINFO, ("Setting transmission delay: %d\n", value));
bus_w(CONFIG_REG, (bus_r(CONFIG_REG) &~CONFIG_TDMA_TIMESLOT_MSK)
| (((value << CONFIG_TDMA_TIMESLOT_OFST) & CONFIG_TDMA_TIMESLOT_MSK)));
if (value == 0) {
FILE_LOG(logINFO, ("Switching off transmission delay\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) &~ CONFIG_TDMA_ENABLE_MSK);
} else {
FILE_LOG(logINFO, ("Switching on transmission delay\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) | CONFIG_TDMA_ENABLE_MSK);
}
FILE_LOG(logDEBUG1, ("Transmission delay read %d\n",
((bus_r(CONFIG_REG) & CONFIG_TDMA_TIMESLOT_MSK) >> CONFIG_TDMA_TIMESLOT_OFST)));
}
return ((bus_r(CONFIG_REG) & CONFIG_TDMA_TIMESLOT_MSK) >> CONFIG_TDMA_TIMESLOT_OFST);
case FLOWCTRL_10G:
if (value >= 0) {
if (value == 0) {
FILE_LOG(logINFO, ("Switching off 10G flow control\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) &~ CONFIG_ETHRNT_FLW_CNTRL_MSK);
} else {
FILE_LOG(logINFO, ("Switching on 10G flow control\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) | CONFIG_ETHRNT_FLW_CNTRL_MSK);
}
}
return ((bus_r(CONFIG_REG) & CONFIG_ETHRNT_FLW_CNTRL_MSK) >> CONFIG_ETHRNT_FLW_CNTRL_OFST);
default:
return -1;
}
int getTenGigaFlowControl() {
return ((bus_r(CONFIG_REG) & CONFIG_ETHRNT_FLW_CNTRL_MSK) >> CONFIG_ETHRNT_FLW_CNTRL_OFST);
}
int setTenGigaFlowControl(int value) {
if (value >= 0) {
if (value == 0) {
FILE_LOG(logINFO, ("Switching off 10G flow control\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) &~ CONFIG_ETHRNT_FLW_CNTRL_MSK);
} else {
FILE_LOG(logINFO, ("Switching on 10G flow control\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) | CONFIG_ETHRNT_FLW_CNTRL_MSK);
}
}
return OK;
}
int getTransmissionDelayFrame() {
return ((bus_r(CONFIG_REG) & CONFIG_TDMA_TIMESLOT_MSK) >> CONFIG_TDMA_TIMESLOT_OFST);
}
int setTransmissionDelayFrame(int value) {
if (value >= 0) {
FILE_LOG(logINFO, ("Setting transmission delay: %d\n", value));
bus_w(CONFIG_REG, (bus_r(CONFIG_REG) &~CONFIG_TDMA_TIMESLOT_MSK)
| (((value << CONFIG_TDMA_TIMESLOT_OFST) & CONFIG_TDMA_TIMESLOT_MSK)));
if (value == 0) {
FILE_LOG(logINFO, ("Switching off transmission delay\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) &~ CONFIG_TDMA_ENABLE_MSK);
} else {
FILE_LOG(logINFO, ("Switching on transmission delay\n"));
bus_w(CONFIG_REG, bus_r(CONFIG_REG) | CONFIG_TDMA_ENABLE_MSK);
}
FILE_LOG(logDEBUG1, ("Transmission delay read %d\n",
((bus_r(CONFIG_REG) & CONFIG_TDMA_TIMESLOT_MSK) >> CONFIG_TDMA_TIMESLOT_OFST)));
}
return OK;
}

BIN
slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
View File

Binary file not shown.

28
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -87,15 +87,15 @@ void basictests() {
uint16_t hversion = getHardwareVersionNumber();
uint32_t ipadd = getDetectorIP();
uint64_t macadd = getDetectorMAC();
int64_t fwversion = getDetectorId(DETECTOR_FIRMWARE_VERSION);
int64_t swversion = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t fwversion = getFirmwareVersion();
int64_t swversion = getServerVersion();
int64_t sw_fw_apiversion = 0;
int64_t client_sw_apiversion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t client_sw_apiversion = getClientServerAPIVersion();
uint32_t requiredFirmwareVersion = REQRD_FRMWRE_VRSN;
if (fwversion >= MIN_REQRD_VRSN_T_RD_API)
sw_fw_apiversion = getDetectorId(SOFTWARE_FIRMWARE_API_VERSION);
sw_fw_apiversion = getFirmwareAPIVersion();
FILE_LOG(logINFOBLUE, ("************ Mythen3 Server *********************\n"
"Hardware Version:\t\t 0x%x\n"
@ -228,22 +228,12 @@ int testBus() {
/* Ids */
int64_t getDetectorId(enum idMode arg){
int64_t retval = -1;
uint64_t getServerVersion() {
return APIMYTHEN3;
}
switch(arg){
case DETECTOR_SERIAL_NUMBER:
return getDetectorNumber();// or getDetectorMAC()
case DETECTOR_FIRMWARE_VERSION:
return getFirmwareVersion();
case SOFTWARE_FIRMWARE_API_VERSION:
return getFirmwareAPIVersion();
case DETECTOR_SOFTWARE_VERSION:
case CLIENT_SOFTWARE_API_VERSION:
return APIMYTHEN3;
default:
return retval;
}
uint64_t getClientServerAPIVersion() {
return APIMYTHEN3;
}
u_int64_t getFirmwareVersion() {

20
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -41,14 +41,13 @@ 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);
void setTestImageMode(int ival);
int getTestImageMode();
#endif
// Ids
int64_t getDetectorId(enum idMode arg);
u_int64_t getServerVersion();
u_int64_t getClientServerAPIVersion();
u_int64_t getFirmwareVersion();
u_int64_t getFirmwareAPIVersion();
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D) || defined(GOTTHARD2D)
@ -445,7 +444,16 @@ int getClockDivider(enum CLKINDEX ind);
#if defined(JUNGFRAUD) || defined(EIGERD)
int setNetworkParameter(enum NETWORKINDEX mode, int value);
int getTenGigaFlowControl();
int setTenGigaFlowControl(int value);
int getTransmissionDelayFrame();
int setTransmissionDelayFrame(int value);
#endif
#ifdef EIGERD
int getTransmissionDelayLeft();
int setTransmissionDelayLeft(int value);
int getTransmissionDelayRight();
int setTransmissionDelayRight(int value);
#endif

18
slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
View File

@ -26,8 +26,13 @@ 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 get_firmware_version(int);
int get_server_version(int);
int get_serial_number(int);
int set_firmware_test(int);
int set_bus_test(int);
int set_image_test_mode(int);
int get_image_test_mode(int);
int set_dac(int);
int get_adc(int);
int write_register(int);
@ -104,7 +109,14 @@ 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 set_ten_giga_flow_control(int);
int get_ten_giga_flow_control(int);
int set_transmission_delay_frame(int);
int get_transmission_delay_frame(int);
int set_transmission_delay_left(int);
int get_transmission_delay_left(int);
int set_transmission_delay_right(int);
int get_transmission_delay_right(int);
int program_fpga(int);
int reset_fpga(int);
int power_chip(int);

421
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -133,8 +133,13 @@ const char* getFunctionName(enum detFuncs func) {
case F_GET_DETECTOR_TYPE: return "F_GET_DETECTOR_TYPE";
case F_SET_EXTERNAL_SIGNAL_FLAG: return "F_SET_EXTERNAL_SIGNAL_FLAG";
case F_SET_TIMING_MODE: return "F_SET_TIMING_MODE";
case F_GET_ID: return "F_GET_ID";
case F_DIGITAL_TEST: return "F_DIGITAL_TEST";
case F_GET_FIRMWARE_VERSION: return "F_GET_FIRMWARE_VERSION";
case F_GET_SERVER_VERSION: return "F_GET_SERVER_VERSION";
case F_GET_SERIAL_NUMBER: return "F_GET_SERIAL_NUMBER";
case F_SET_FIRMWARE_TEST: return "F_SET_FIRMWARE_TEST";
case F_SET_BUS_TEST: return "F_SET_BUS_TEST";
case F_SET_IMAGE_TEST_MODE: return "F_SET_IMAGE_TEST_MODE";
case F_GET_IMAGE_TEST_MODE: return "F_GET_IMAGE_TEST_MODE";
case F_SET_DAC: return "F_SET_DAC";
case F_GET_ADC: return "F_GET_ADC";
case F_WRITE_REGISTER: return "F_WRITE_REGISTER";
@ -209,7 +214,14 @@ const char* getFunctionName(enum detFuncs func) {
case F_PULSE_CHIP: return "F_PULSE_CHIP";
case F_SET_RATE_CORRECT: return "F_SET_RATE_CORRECT";
case F_GET_RATE_CORRECT: return "F_GET_RATE_CORRECT";
case F_SET_NETWORK_PARAMETER: return "F_SET_NETWORK_PARAMETER";
case F_SET_TEN_GIGA_FLOW_CONTROL: return "F_SET_TEN_GIGA_FLOW_CONTROL";
case F_GET_TEN_GIGA_FLOW_CONTROL: return "F_GET_TEN_GIGA_FLOW_CONTROL";
case F_SET_TRANSMISSION_DELAY_FRAME: return "F_SET_TRANSMISSION_DELAY_FRAME";
case F_GET_TRANSMISSION_DELAY_FRAME: return "F_GET_TRANSMISSION_DELAY_FRAME";
case F_SET_TRANSMISSION_DELAY_LEFT: return "F_SET_TRANSMISSION_DELAY_LEFT";
case F_GET_TRANSMISSION_DELAY_LEFT: return "F_GET_TRANSMISSION_DELAY_LEFT";
case F_SET_TRANSMISSION_DELAY_RIGHT: return "F_SET_TRANSMISSION_DELAY_RIGHT";
case F_GET_TRANSMISSION_DELAY_RIGHT: return "F_GET_TRANSMISSION_DELAY_RIGHT";
case F_PROGRAM_FPGA: return "F_PROGRAM_FPGA";
case F_RESET_FPGA: return "F_RESET_FPGA";
case F_POWER_CHIP: return "F_POWER_CHIP";
@ -292,8 +304,13 @@ void function_table() {
flist[F_GET_DETECTOR_TYPE] = &get_detector_type;
flist[F_SET_EXTERNAL_SIGNAL_FLAG] = &set_external_signal_flag;
flist[F_SET_TIMING_MODE] = &set_timing_mode;
flist[F_GET_ID] = &get_id;
flist[F_DIGITAL_TEST] = &digital_test;
flist[F_GET_FIRMWARE_VERSION] = &get_firmware_version;
flist[F_GET_SERVER_VERSION] = &get_server_version;
flist[F_GET_SERIAL_NUMBER] = &get_serial_number;
flist[F_SET_FIRMWARE_TEST] = &set_firmware_test;
flist[F_SET_BUS_TEST] = &set_bus_test;
flist[F_SET_IMAGE_TEST_MODE] = &set_image_test_mode;
flist[F_GET_IMAGE_TEST_MODE] = &get_image_test_mode;
flist[F_SET_DAC] = &set_dac;
flist[F_GET_ADC] = &get_adc;
flist[F_WRITE_REGISTER] = &write_register;
@ -368,7 +385,14 @@ void function_table() {
flist[F_PULSE_CHIP] = &pulse_chip;
flist[F_SET_RATE_CORRECT] = &set_rate_correct;
flist[F_GET_RATE_CORRECT] = &get_rate_correct;
flist[F_SET_NETWORK_PARAMETER] = &set_network_parameter;
flist[F_SET_TEN_GIGA_FLOW_CONTROL] = &set_ten_giga_flow_control;
flist[F_GET_TEN_GIGA_FLOW_CONTROL] = &get_ten_giga_flow_control;
flist[F_SET_TRANSMISSION_DELAY_FRAME] = &set_transmission_delay_frame;
flist[F_GET_TRANSMISSION_DELAY_FRAME] = &get_transmission_delay_frame;
flist[F_SET_TRANSMISSION_DELAY_LEFT] = &set_transmission_delay_left;
flist[F_GET_TRANSMISSION_DELAY_LEFT] = &get_transmission_delay_left;
flist[F_SET_TRANSMISSION_DELAY_RIGHT] = &set_transmission_delay_right;
flist[F_GET_TRANSMISSION_DELAY_RIGHT] = &get_transmission_delay_right;
flist[F_PROGRAM_FPGA] = &program_fpga;
flist[F_RESET_FPGA] = &reset_fpga;
flist[F_POWER_CHIP] = &power_chip;
@ -666,78 +690,87 @@ int set_timing_mode(int file_des) {
int get_id(int file_des) {
int get_firmware_version(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum idMode arg = 0;
int64_t retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Getting Id %d\n", arg));
// get
switch (arg) {
#ifndef GOTTHARDD
case SOFTWARE_FIRMWARE_API_VERSION:
case DETECTOR_SERIAL_NUMBER:
#endif
case DETECTOR_FIRMWARE_VERSION:
case DETECTOR_SOFTWARE_VERSION:
retval = getDetectorId(arg);
FILE_LOG(logDEBUG1, ("Id(%d): %lld\n", retval));
break;
default:
modeNotImplemented("ID Index", (int)arg);
break;
}
retval = getFirmwareVersion();
FILE_LOG(logDEBUG1, ("firmware version retval: 0x%llx\n", (long long int)retval));
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
int digital_test(int file_des) {
int get_server_version(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1, -1};
int retval = -1;
int64_t retval = -1;
retval = getServerVersion();
FILE_LOG(logDEBUG1, ("firmware version retval: 0x%llx\n", (long long int)retval));
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum digitalTestMode mode = args[0];
#ifdef GOTTHARDD
int ival = args[1];
FILE_LOG(logDEBUG1, ("Digital test, mode = %d, ival:%d\n", mode, ival));
#else
FILE_LOG(logDEBUG1, ("Digital test, mode = %d\n", mode));
#endif
int get_serial_number(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int64_t retval = -1;
retval = getDetectorNumber();
FILE_LOG(logDEBUG1, ("firmware version retval: 0x%llx\n", (long long int)retval));
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
#if defined(EIGERD) || defined(MYTHEN3D) || defined(GOTTHARD2D)
int set_firmware_test(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Executing firmware test\n"));
#if !defined(GOTTHARDD) && !defined(JUNGFRAUD) && !defined(CHIPTESTBOARDD) && !defined(MOENCHD) && !defined(GOTTHARD2D) && !defined(MYTHEN3D)
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
switch (mode) {
case DETECTOR_FIRMWARE_TEST:
case DETECTOR_BUS_TEST:
#ifdef GOTTHARDD
case IMAGE_TEST:
retval = detectorTest(mode, ival);
break;
#else
retval = detectorTest(mode);
ret = testFpga();
#endif
FILE_LOG(logDEBUG1, ("Digital Test (%d): %d\n", mode, retval));
break;
default:
modeNotImplemented("Digital Test Mode", (int)mode);
break;
}
}
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int set_bus_test(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Executing bus test\n"));
#if !defined(GOTTHARDD) && !defined(JUNGFRAUD) && !defined(CHIPTESTBOARDD) && !defined(MOENCHD) && !defined(GOTTHARD2D) && !defined(MYTHEN3D)
functionNotImplemented();
#else
ret = testBus();
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int set_image_test_mode(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting image test mode to \n", arg));
#ifndef GOTTHARDD
functionNotImplemented();
#else
setTestImageMode(arg);
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_image_test_mode(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int retval = -1;
FILE_LOG(logDEBUG1, ("Getting image test mode\n"));
#ifndef GOTTHARDD
functionNotImplemented();
#else
retval = getTestImageMode();
FILE_LOG(logDEBUG1, ("image test mode retval: %d\n", retval));
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
@ -746,7 +779,6 @@ int digital_test(int file_des) {
int set_dac(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
@ -3365,70 +3397,221 @@ int get_rate_correct(int file_des) {
int set_network_parameter(int file_des) {
ret = OK;
int set_ten_giga_flow_control(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1,-1};
int retval = -1;
int arg = 0;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum networkParameter mode = args[0];
int value = args[1];
FILE_LOG(logDEBUG1, ("Set network parameter index %d to %d\n", mode, value));
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logINFO, ("Setting ten giga flow control: %d\n", arg));
#if defined(GOTTHARDD) || defined (CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D) || defined(GOTTHARD2D)
#if !defined(EIGERD) && !defined(JUNGFRAUD)
functionNotImplemented();
#else
enum NETWORKINDEX serverIndex = 0;
// set & get
if ((value == -1) || (Server_VerifyLock() == OK)) {
// check index
switch (mode) {
case FLOW_CONTROL_10G:
serverIndex = FLOWCTRL_10G;
break;
#ifdef EIGERD
case DETECTOR_TXN_DELAY_LEFT:
serverIndex = TXN_LEFT;
break;
case DETECTOR_TXN_DELAY_RIGHT:
serverIndex = TXN_RIGHT;
break;
#endif
case DETECTOR_TXN_DELAY_FRAME:
serverIndex = TXN_FRAME;
#ifdef JUNGFRAUD
if (value > MAX_TIMESLOT_VAL) {
ret = FAIL;
sprintf(mess,"Transmission delay %d should be in range: 0 - %d\n",
value, MAX_TIMESLOT_VAL);
FILE_LOG(logERROR, (mess));
}
#endif
break;
default:
modeNotImplemented("Image index", (int)serverIndex);
break;
}
// valid index
if (ret == OK) {
retval = setNetworkParameter(serverIndex, value);
FILE_LOG(logDEBUG1, ("Network Parameter index %d: %d\n", serverIndex, retval));
validate(value, retval, "set network parameter", DEC);
// only set
if (Server_VerifyLock() == OK) {
ret = setTenGigaFlowControl(arg);
if (ret == FAIL) {
strcpy(mess,"Could not set ten giga flow control.\n");
FILE_LOG(logERROR,(mess));
} else {
int retval = getTenGigaFlowControl();
FILE_LOG(logDEBUG1, ("ten giga flow control retval: %d\n", retval));
validate(arg, retval, "set ten giga flow control", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_ten_giga_flow_control(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int retval = -1;
FILE_LOG(logDEBUG1, ("Getting ten giga flow control\n"));
#if !defined(EIGERD) && !defined(JUNGFRAUD)
functionNotImplemented();
#else
// get only
retval = getTenGigaFlowControl();
FILE_LOG(logDEBUG1, ("ten giga flow control retval: %d\n", retval));
if (retval == -1) {
strcpy(mess,"Could not get ten giga flow control.\n");
FILE_LOG(logERROR,(mess));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_transmission_delay_frame(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = 0;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logINFO, ("Setting transmission delay frame: %d\n", arg));
#if !defined(EIGERD) && !defined(JUNGFRAUD)
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
#ifdef JUNGFRAUD
if (arg > MAX_TIMESLOT_VAL) {
ret = FAIL;
sprintf(mess,"Transmission delay %d should be in range: 0 - %d\n",
arg, MAX_TIMESLOT_VAL);
FILE_LOG(logERROR, (mess));
}
#endif
if (ret == OK) {
ret = setTransmissionDelayFrame(arg);
if (ret == FAIL) {
strcpy(mess,"Could not set transmission delay frame.\n");
FILE_LOG(logERROR,(mess));
} else {
int retval = getTransmissionDelayFrame();
FILE_LOG(logDEBUG1, ("transmission delay frame retval: %d\n", retval));
validate(arg, retval, "set transmission delay frame", DEC);
}
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_transmission_delay_frame(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int retval = -1;
FILE_LOG(logDEBUG1, ("Getting transmission delay frame\n"));
#if !defined(EIGERD) && !defined(JUNGFRAUD)
functionNotImplemented();
#else
// get only
retval = getTransmissionDelayFrame();
FILE_LOG(logDEBUG1, ("transmission delay frame retval: %d\n", retval));
if (retval == -1) {
strcpy(mess,"Could not get transmission delay frame.\n");
FILE_LOG(logERROR,(mess));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_transmission_delay_left(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = 0;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logINFO, ("Setting transmission delay left: %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = setTransmissionDelayLeft(arg);
if (ret == FAIL) {
strcpy(mess,"Could not set transmission delay left.\n");
FILE_LOG(logERROR,(mess));
} else {
int retval = getTransmissionDelayLeft();
FILE_LOG(logDEBUG1, ("transmission delay left retval: %d\n", retval));
validate(arg, retval, "set transmission delay left", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_transmission_delay_left(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int retval = -1;
FILE_LOG(logDEBUG1, ("Getting transmission delay left\n"));
#ifndef EIGERD
functionNotImplemented();
#else
// get only
retval = getTransmissionDelayLeft();
FILE_LOG(logDEBUG1, ("transmission delay left: %d\n", retval));
if (retval == -1) {
strcpy(mess,"Could not get transmission delay left.\n");
FILE_LOG(logERROR,(mess));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_transmission_delay_right(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = 0;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logINFO, ("Setting transmission delay right: %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = setTransmissionDelayRight(arg);
if (ret == FAIL) {
strcpy(mess,"Could not set transmission delay right.\n");
FILE_LOG(logERROR,(mess));
} else {
int retval = getTransmissionDelayRight();
FILE_LOG(logDEBUG1, ("transmission delay right retval: %d\n", retval));
validate(arg, retval, "set transmission delay right", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_transmission_delay_right(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int retval = -1;
FILE_LOG(logDEBUG1, ("Getting transmission delay right\n"));
#ifndef EIGERD
functionNotImplemented();
#else
// get only
retval = getTransmissionDelayRight();
FILE_LOG(logDEBUG1, ("transmission delay right retval: %d\n", retval));
if (retval == -1) {
strcpy(mess,"Could not get transmission delay right.\n");
FILE_LOG(logERROR,(mess));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
@ -3825,8 +4008,8 @@ int check_version(int file_des) {
FILE_LOG(logDEBUG1, ("Checking versioning compatibility with value 0x%llx\n",arg));
int64_t client_requiredVersion = arg;
int64_t det_apiVersion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t det_version = getDetectorId(DETECTOR_SOFTWARE_VERSION);
int64_t det_apiVersion = getClientServerAPIVersion();
int64_t det_version = getServerVersion();
// old client
if (det_apiVersion > client_requiredVersion) {