detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-24 23:30:03 +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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
slsDetectorGui/src/qTabDebugging.cpp
View File

@ -186,25 +186,20 @@ void qTabDebugging::TestDetector() {
//detector firmware
if (chkDetectorFirmware->isChecked()) {
auto retval = det->executeFirmwareTest({comboDetector->currentIndex()})[0];
if (retval == slsDetectorDefs::FAIL) {
message.append(QString("<nobr>%1 Firmware: FAIL</nobr><br>").arg(moduleName));
FILE_LOG(logERROR) << "Firmware fail";
}
else
message.append(QString("<nobr>%1 Firmware: %2</nobr><br>").arg(moduleName, QString::number(retval)));
FILE_LOG(logINFO) << "Detector Firmware Test: " << retval;
try {
det->executeFirmwareTest({comboDetector->currentIndex()});
message.append(QString("<nobr>%1 Firmware: PASS</nobr><br>").arg(moduleName));
FILE_LOG(logINFO) << "Detector Firmware Test: Pass";
} CATCH_DISPLAY ("Firmware test failed.", "qTabDebugging::TestDetector")
}
//detector CPU-FPGA bus
if (chkDetectorBus->isChecked()) {
auto retval = det->executeBusTest({comboDetector->currentIndex()})[0];
if (retval == slsDetectorDefs::FAIL) {
message.append(QString("<nobr>%1 Bus: &nbsp;&nbsp;&nbsp;&nbsp;FAIL</nobr><br>").arg(moduleName));
FILE_LOG(logERROR) << "Bus Test fail";
} else
message.append(QString("<nobr>%1 Bus: &nbsp;&nbsp;&nbsp;&nbsp;%2</nobr><br>").arg(moduleName, QString::number(retval)));
FILE_LOG(logINFO) << "Detector Bus Test: " << retval;
try {
det->executeBusTest({comboDetector->currentIndex()});
message.append(QString("<nobr>%1 Bus: PASS</nobr><br>").arg(moduleName));
FILE_LOG(logINFO) << "Detector Bus Test: Pass";
} CATCH_DISPLAY ("Bus test failed.", "qTabDebugging::TestDetector")
}
//display message

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

6
slsDetectorSoftware/include/Detector.h
View File

@ -865,7 +865,7 @@ class Detector {
/** [Gotthard] If 1, adds channel intensity with precalculated values.
* Default is 0 */
Result<int> setImageTestMode(const int value, Positions pos = {});
void setImageTestMode(const int value, Positions pos = {});
/**************************************************
* *
@ -1182,10 +1182,10 @@ class Detector {
void clearBit(uint32_t addr, int bitnr, Positions pos = {});
/** [Gotthard][Jungfrau][CTB] */
Result<int> executeFirmwareTest(Positions pos = {});
void executeFirmwareTest(Positions pos = {});
/** [Gotthard][Jungfrau][CTB] */
Result<int> executeBusTest(Positions pos = {});
void executeBusTest(Positions pos = {});
/** [Gotthard][Jungfrau][CTB] not possible to read back*/
void writeAdcRegister(uint32_t addr, uint32_t value, Positions pos = {});

70
slsDetectorSoftware/include/slsDetector.h
View File

@ -223,12 +223,11 @@ class slsDetector : public virtual slsDetectorDefs {
*/
void checkDetectorVersionCompatibility();
/**
* Get ID or version numbers
* @param mode version type
* @returns Id or version number of that type
*/
int64_t getId(idMode mode);
int64_t getFirmwareVersion();
int64_t getDetectorServerVersion();
int64_t getSerialNumber();
/**
* Get Receiver Software version
@ -994,14 +993,42 @@ class slsDetector : public virtual slsDetectorDefs {
*/
void updateReceiverStreamingIP();
/** [Eiger, Jungfrau] */
bool getTenGigaFlowControl();
/** [Eiger, Jungfrau] */
void setTenGigaFlowControl(bool enable);
/** [Eiger, Jungfrau] */
int getTransmissionDelayFrame();
/**
* Sets the transmission delay for left, right or entire frame
* (Eiger, Jungfrau(only entire frame))
* @param index type of delay
* @param delay delay
* @returns transmission delay
* [Jungfrau]: Sets the transmission delay of the first UDP packet being
* streamed out of the module. Options: 0 - 31, each value represenets 1 ms
* [Eiger]: Sets the transmission delay of entire frame streamed out for
* both left and right UDP ports. Options: //TODO possible values
*/
int setDetectorNetworkParameter(networkParameter index, int delay);
void setTransmissionDelayFrame(int value);
/** [Eiger] */
int getTransmissionDelayLeft();
/**
* [Eiger]
* Sets the transmission delay of first packet streamed out of the left UDP
* port
*/
void setTransmissionDelayLeft(int value);
/** [Eiger] */
int getTransmissionDelayRight();
/**
* [Eiger]
* Sets the transmission delay of first packet streamed ut of the right UDP
* port
*/
void setTransmissionDelayRight(int value);
/**
* Sets the additional json header\sa sharedSlsDetector
@ -1056,13 +1083,18 @@ class slsDetector : public virtual slsDetectorDefs {
*/
int64_t getReceiverRealUDPSocketBufferSize() const;
/**
* Execute a digital test (Gotthard, Jungfrau, CTB)
* @param mode testmode type
* @param value 1 to set or 0 to clear the digital test bit
* @returns result of test
*/
int digitalTest(digitalTestMode mode, int ival = -1);
/** [Gotthard][Jungfrau][CTB] */
void executeFirmwareTest();
/** [Gotthard][Jungfrau][CTB] */
void executeBusTest();
/** [Gotthard] */
int getImageTestMode();
/** [Gotthard] If 1, adds channel intensity with precalculated values.
* Default is 0 */
void setImageTestMode(const int value);
/**
* Set/get counter bit in detector (Gotthard)

51
slsDetectorSoftware/src/Detector.cpp
View File

@ -48,18 +48,15 @@ int64_t Detector::getClientVersion() const {
}
Result<int64_t> Detector::getFirmwareVersion(Positions pos) const {
return pimpl->Parallel(&slsDetector::getId, pos,
defs::DETECTOR_FIRMWARE_VERSION);
return pimpl->Parallel(&slsDetector::getFirmwareVersion, pos);
}
Result<int64_t> Detector::getDetectorServerVersion(Positions pos) const {
return pimpl->Parallel(&slsDetector::getId, pos,
defs::DETECTOR_SOFTWARE_VERSION);
return pimpl->Parallel(&slsDetector::getDetectorServerVersion, pos);
}
Result<int64_t> Detector::getSerialNumber(Positions pos) const {
return pimpl->Parallel(&slsDetector::getId, pos,
defs::DETECTOR_SERIAL_NUMBER);
return pimpl->Parallel(&slsDetector::getSerialNumber, pos);
}
Result<int64_t> Detector::getReceiverVersion(Positions pos) const {
@ -485,43 +482,35 @@ void Detector::setTenGiga(bool value, Positions pos) {
}
Result<bool> Detector::getTenGigaFlowControl(Positions pos) const {
return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::FLOW_CONTROL_10G, -1);
return pimpl->Parallel(&slsDetector::getTenGigaFlowControl, pos);
}
void Detector::setTenGigaFlowControl(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::FLOW_CONTROL_10G, static_cast<int>(enable));
pimpl->Parallel(&slsDetector::setTenGigaFlowControl, pos, enable);
}
Result<int> Detector::getTransmissionDelayFrame(Positions pos) const {
return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::DETECTOR_TXN_DELAY_FRAME, -1);
return pimpl->Parallel(&slsDetector::getTransmissionDelayFrame, pos);
}
void Detector::setTransmissionDelayFrame(int value, Positions pos) {
pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::DETECTOR_TXN_DELAY_FRAME, value);
pimpl->Parallel(&slsDetector::setTransmissionDelayFrame, pos, value);
}
Result<int> Detector::getTransmissionDelayLeft(Positions pos) const {
return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::DETECTOR_TXN_DELAY_LEFT, -1);
return pimpl->Parallel(&slsDetector::getTransmissionDelayLeft, pos);
}
void Detector::setTransmissionDelayLeft(int value, Positions pos) {
pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::DETECTOR_TXN_DELAY_LEFT, value);
pimpl->Parallel(&slsDetector::setTransmissionDelayLeft, pos, value);
}
Result<int> Detector::getTransmissionDelayRight(Positions pos) const {
return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::DETECTOR_TXN_DELAY_RIGHT, -1);
return pimpl->Parallel(&slsDetector::getTransmissionDelayRight, pos);
}
void Detector::setTransmissionDelayRight(int value, Positions pos) {
pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
defs::DETECTOR_TXN_DELAY_RIGHT, value);
pimpl->Parallel(&slsDetector::setTransmissionDelayRight, pos, value);
}
// Receiver
@ -1082,13 +1071,11 @@ void Detector::setExternalSignalFlags(defs::externalSignalFlag value,
}
Result<int> Detector::getImageTestMode(Positions pos) {
return pimpl->Parallel(&slsDetector::digitalTest, pos, defs::IMAGE_TEST,
-1);
return pimpl->Parallel(&slsDetector::getImageTestMode, pos);
}
Result<int> Detector::setImageTestMode(int value, Positions pos) {
return pimpl->Parallel(&slsDetector::digitalTest, pos, defs::IMAGE_TEST,
value);
void Detector::setImageTestMode(int value, Positions pos) {
pimpl->Parallel(&slsDetector::setImageTestMode, pos, value);
}
// CTB Specific
@ -1527,14 +1514,12 @@ void Detector::clearBit(uint32_t addr, int bitnr, Positions pos) {
pimpl->Parallel(&slsDetector::clearBit, pos, addr, bitnr);
}
Result<int> Detector::executeFirmwareTest(Positions pos) {
return pimpl->Parallel(&slsDetector::digitalTest, pos,
defs::DETECTOR_FIRMWARE_TEST, -1);
void Detector::executeFirmwareTest(Positions pos) {
pimpl->Parallel(&slsDetector::executeFirmwareTest, pos);
}
Result<int> Detector::executeBusTest(Positions pos) {
return pimpl->Parallel(&slsDetector::digitalTest, pos,
defs::DETECTOR_BUS_TEST, -1);
void Detector::executeBusTest(Positions pos) {
pimpl->Parallel(&slsDetector::executeBusTest, pos);
}
void Detector::writeAdcRegister(uint32_t addr, uint32_t value, Positions pos) {

118
slsDetectorSoftware/src/slsDetector.cpp
View File

@ -104,27 +104,33 @@ void slsDetector::checkReceiverVersionCompatibility() {
sendToReceiver(F_RECEIVER_CHECK_VERSION, arg, nullptr);
}
int64_t slsDetector::getId(idMode mode) {
// These should not go to detector...
assert(mode != THIS_SOFTWARE_VERSION);
assert(mode != RECEIVER_VERSION);
assert(mode != CLIENT_SOFTWARE_API_VERSION);
assert(mode != CLIENT_RECEIVER_API_VERSION);
int arg = static_cast<int>(mode);
int64_t slsDetector::getFirmwareVersion() {
int64_t retval = -1;
FILE_LOG(logDEBUG1) << "Getting id type " << mode;
sendToDetector(F_GET_ID, arg, retval);
FILE_LOG(logDEBUG1) << "Id (" << mode << "): 0x" << std::hex << retval
<< std::dec;
sendToDetector(F_GET_FIRMWARE_VERSION, nullptr, retval);
FILE_LOG(logDEBUG1) << "firmware version: 0x" << std::hex << retval << std::dec;
return retval;
}
int64_t slsDetector::getDetectorServerVersion() {
int64_t retval = -1;
sendToDetector(F_GET_SERVER_VERSION, nullptr, retval);
FILE_LOG(logDEBUG1) << "firmware version: 0x" << std::hex << retval << std::dec;
return retval;
}
int64_t slsDetector::getSerialNumber() {
int64_t retval = -1;
sendToDetector(F_GET_SERIAL_NUMBER, nullptr, retval);
FILE_LOG(logDEBUG1) << "firmware version: 0x" << std::hex << retval << std::dec;
return retval;
}
int64_t slsDetector::getReceiverSoftwareVersion() const {
FILE_LOG(logDEBUG1) << "Getting receiver software version";
int64_t retval = -1;
if (shm()->useReceiverFlag) {
sendToReceiver(F_GET_RECEIVER_ID, nullptr, retval);
sendToReceiver(F_GET_RECEIVER_VERSION, nullptr, retval);
}
return retval;
}
@ -1049,7 +1055,7 @@ std::string slsDetector::getTrimbitFilename(detectorSettings s, int e_eV) {
std::ostringstream ostfn;
ostfn << shm()->settingsDir << ssettings << "/" << e_eV << "eV"
<< "/noise.sn" << std::setfill('0') << std::setw(3) << std::dec
<< getId(DETECTOR_SERIAL_NUMBER) << std::setbase(10);
<< getSerialNumber() << std::setbase(10);
return ostfn.str();
}
@ -1073,7 +1079,7 @@ void slsDetector::loadSettingsFile(const std::string &fname) {
fname.find(".trim") == std::string::npos &&
fname.find(".settings") == std::string::npos) {
ostfn << ".sn" << std::setfill('0') << std::setw(3) << std::dec
<< getId(DETECTOR_SERIAL_NUMBER);
<< getSerialNumber();
}
}
fn = ostfn.str();
@ -1089,7 +1095,7 @@ void slsDetector::saveSettingsFile(const std::string &fname) {
// find specific file if it has detid in file name (.snxxx)
if (shm()->myDetectorType == EIGER) {
ostfn << ".sn" << std::setfill('0') << std::setw(3) << std::dec
<< getId(DETECTOR_SERIAL_NUMBER);
<< getSerialNumber();
}
fn = ostfn.str();
sls_detector_module myMod = getModule();
@ -2110,17 +2116,57 @@ void slsDetector::updateReceiverStreamingIP() {
setReceiverStreamingIP(ip);
}
int slsDetector::setDetectorNetworkParameter(networkParameter index,
int delay) {
int args[]{static_cast<int>(index), delay};
bool slsDetector::getTenGigaFlowControl() {
int retval = -1;
FILE_LOG(logDEBUG1) << "Setting network parameter index " << index << " to "
<< delay;
sendToDetector(F_SET_NETWORK_PARAMETER, args, retval);
FILE_LOG(logDEBUG1) << "Network Parameter (" << index << "): " << retval;
return retval;
sendToDetector(F_GET_TEN_GIGA_FLOW_CONTROL, nullptr, retval);
FILE_LOG(logDEBUG1) << "ten giga flow control :" << retval;
return retval == 1 ? true : false;
}
void slsDetector::setTenGigaFlowControl(bool enable) {
int arg = static_cast<int>(enable);
FILE_LOG(logDEBUG1) << "Setting ten giga flow control to " << arg;
sendToDetector(F_SET_TEN_GIGA_FLOW_CONTROL, arg, nullptr);
}
int slsDetector::getTransmissionDelayFrame() {
int retval = -1;
sendToDetector(F_GET_TRANSMISSION_DELAY_FRAME, nullptr, retval);
FILE_LOG(logDEBUG1) << "transmission delay frame :" << retval;
return retval;
}
void slsDetector::setTransmissionDelayFrame(int value) {
FILE_LOG(logDEBUG1) << "Setting transmission delay frame to " << value;
sendToDetector(F_SET_TRANSMISSION_DELAY_FRAME, value, nullptr);
}
int slsDetector::getTransmissionDelayLeft() {
int retval = -1;
sendToDetector(F_GET_TRANSMISSION_DELAY_LEFT, nullptr, retval);
FILE_LOG(logDEBUG1) << "transmission delay left :" << retval;
return retval;
}
void slsDetector::setTransmissionDelayLeft(int value) {
FILE_LOG(logDEBUG1) << "Setting transmission delay left to " << value;
sendToDetector(F_SET_TRANSMISSION_DELAY_LEFT, value, nullptr);
}
int slsDetector::getTransmissionDelayRight() {
int retval = -1;
sendToDetector(F_GET_TRANSMISSION_DELAY_RIGHT, nullptr, retval);
FILE_LOG(logDEBUG1) << "transmission delay right :" << retval;
return retval;
}
void slsDetector::setTransmissionDelayRight(int value) {
FILE_LOG(logDEBUG1) << "Setting transmission delay right to " << value;
sendToDetector(F_SET_TRANSMISSION_DELAY_RIGHT, value, nullptr);
}
std::string
slsDetector::setAdditionalJsonHeader(const std::string &jsonheader) {
int fnum = F_ADDITIONAL_JSON_HEADER;
@ -2262,16 +2308,28 @@ int64_t slsDetector::getReceiverRealUDPSocketBufferSize() const {
return retval;
}
int slsDetector::digitalTest(digitalTestMode mode, int ival) {
int args[]{static_cast<int>(mode), ival};
void slsDetector::executeFirmwareTest() {
FILE_LOG(logDEBUG1) << "Executing firmware test";
sendToDetector(F_SET_FIRMWARE_TEST);
}
void slsDetector::executeBusTest() {
FILE_LOG(logDEBUG1) << "Executing bus test";
sendToDetector(F_SET_BUS_TEST);
}
int slsDetector::getImageTestMode() {
int retval = -1;
FILE_LOG(logDEBUG1) << "Sending digital test of mode " << mode << ", ival "
<< ival;
sendToDetector(F_DIGITAL_TEST, args, retval);
FILE_LOG(logDEBUG1) << "Digital Test returned: " << retval;
sendToDetector(F_GET_IMAGE_TEST_MODE, nullptr, retval);
FILE_LOG(logDEBUG1) << "image test mode: " << retval;
return retval;
}
void slsDetector::setImageTestMode(const int value) {
FILE_LOG(logDEBUG1) << "Sending image test mode " << value;
sendToDetector(F_SET_IMAGE_TEST_MODE, value, nullptr);
}
int slsDetector::setCounterBit(int cb) {
int retval = -1;
FILE_LOG(logDEBUG1) << "Sending counter bit " << cb;

4
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@ -147,8 +147,8 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
/** Sends the updated parameters to client */
int send_update(sls::ServerInterface2 &socket);
/** get version, calls get_version */
int get_id(sls::ServerInterface2 &socket);
/** get version */
int get_version(sls::ServerInterface2 &socket);
/** Set detector type */
int set_detector_type(sls::ServerInterface2 &socket);

4
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@ -153,7 +153,7 @@ int slsReceiverTCPIPInterface::function_table(){
flist[F_GET_LAST_RECEIVER_CLIENT_IP] = &slsReceiverTCPIPInterface::get_last_client_ip;
flist[F_SET_RECEIVER_PORT] = &slsReceiverTCPIPInterface::set_port;
flist[F_UPDATE_RECEIVER_CLIENT] = &slsReceiverTCPIPInterface::update_client;
flist[F_GET_RECEIVER_ID] = &slsReceiverTCPIPInterface::get_id;
flist[F_GET_RECEIVER_VERSION] = &slsReceiverTCPIPInterface::get_version;
flist[F_GET_RECEIVER_TYPE] = &slsReceiverTCPIPInterface::set_detector_type;
flist[F_SEND_RECEIVER_DETHOSTNAME] = &slsReceiverTCPIPInterface::set_detector_hostname;
flist[F_RECEIVER_SET_ROI] = &slsReceiverTCPIPInterface::set_roi;
@ -453,7 +453,7 @@ int slsReceiverTCPIPInterface::send_update(Interface &socket) {
return OK;
}
int slsReceiverTCPIPInterface::get_id(Interface &socket) {
int slsReceiverTCPIPInterface::get_version(Interface &socket) {
return socket.sendResult(getReceiverVersion());
}

65
slsSupportLib/include/sls_detector_defs.h
View File

@ -198,37 +198,6 @@ format
} ROI;
#endif
/**
network parameters
*/
enum networkParameter {
DETECTOR_MAC, /**< detector MAC */
DETECTOR_IP, /**< detector IP */
RECEIVER_HOSTNAME, /**< receiver IP/hostname */
RECEIVER_UDP_IP, /**< receiever UDP IP */
RECEIVER_UDP_PORT, /**< receiever UDP Port */
RECEIVER_UDP_MAC, /**< receiever UDP MAC */
RECEIVER_UDP_PORT2, /**< receiever UDP Port of second half module for
eiger */
DETECTOR_TXN_DELAY_LEFT, /**< transmission delay on the (left) port for
next frame */
DETECTOR_TXN_DELAY_RIGHT, /**< transmission delay on the right port for
next frame */
DETECTOR_TXN_DELAY_FRAME, /**< transmission delay of a whole frame for
all the ports */
FLOW_CONTROL_10G, /**< flow control for 10GbE */
FLOW_CONTROL_WR_PTR, /**< memory write pointer for flow control */
FLOW_CONTROL_RD_PTR, /**< memory read pointer for flow control */
RECEIVER_STREAMING_PORT, /**< receiever streaming TCP(ZMQ) port */
CLIENT_STREAMING_PORT, /**< client streaming TCP(ZMQ) port */
RECEIVER_STREAMING_SRC_IP, /**< receiever streaming TCP(ZMQ) ip */
CLIENT_STREAMING_SRC_IP, /**< client streaming TCP(ZMQ) ip */
ADDITIONAL_JSON_HEADER, /**< additional json header (ZMQ) */
RECEIVER_UDP_SCKT_BUF_SIZE, /**< UDP socket buffer size */
RECEIVER_REAL_UDP_SCKT_BUF_SIZE /**< real UDP socket buffer size */
};
/**
type of action performed (for text client)
*/
@ -249,13 +218,7 @@ format
int y;
};
#endif
/**
enable/disable flags
*/
enum {
DISABLED, /**<flag disabled */
ENABLED /**<flag enabled */
};
/**
use of the external signals
@ -296,32 +259,6 @@ format
GATED, /**< gated */
BURST_TRIGGER /**< trigger a burst of frames */
};
/**
detector IDs/versions
*/
enum idMode {
DETECTOR_SERIAL_NUMBER, /**<return detector system serial number */
DETECTOR_FIRMWARE_VERSION, /**<return detector system firmware version
*/
DETECTOR_SOFTWARE_VERSION, /**<return detector system software version
*/
THIS_SOFTWARE_VERSION, /**<return this software version */
RECEIVER_VERSION, /**<return receiver software version */
SOFTWARE_FIRMWARE_API_VERSION, /** return software firmware API version
*/
CLIENT_SOFTWARE_API_VERSION, /** return detector software and client api
version */
CLIENT_RECEIVER_API_VERSION /** return client and receiver api version
*/
};
/**
detector digital test modes
*/
enum digitalTestMode {
DETECTOR_FIRMWARE_TEST, /**< test detector system firmware */
DETECTOR_BUS_TEST, /**< test detector system CPU-FPGA bus */
IMAGE_TEST /**< gotthard digital bit test */
};
/**
detector dacs indexes

40
slsSupportLib/include/sls_detector_funcs.h
View File

@ -14,8 +14,13 @@ enum detFuncs{
F_GET_DETECTOR_TYPE,
F_SET_EXTERNAL_SIGNAL_FLAG,
F_SET_TIMING_MODE,
F_GET_ID,
F_DIGITAL_TEST,
F_GET_FIRMWARE_VERSION,
F_GET_SERVER_VERSION,
F_GET_SERIAL_NUMBER,
F_SET_FIRMWARE_TEST,
F_SET_BUS_TEST,
F_SET_IMAGE_TEST_MODE,
F_GET_IMAGE_TEST_MODE,
F_SET_DAC,
F_GET_ADC,
F_WRITE_REGISTER,
@ -90,7 +95,14 @@ enum detFuncs{
F_PULSE_CHIP,
F_SET_RATE_CORRECT,
F_GET_RATE_CORRECT,
F_SET_NETWORK_PARAMETER,
F_SET_TEN_GIGA_FLOW_CONTROL,
F_GET_TEN_GIGA_FLOW_CONTROL,
F_SET_TRANSMISSION_DELAY_FRAME,
F_GET_TRANSMISSION_DELAY_FRAME,
F_SET_TRANSMISSION_DELAY_LEFT,
F_GET_TRANSMISSION_DELAY_LEFT,
F_SET_TRANSMISSION_DELAY_RIGHT,
F_GET_TRANSMISSION_DELAY_RIGHT,
F_PROGRAM_FPGA,
F_RESET_FPGA,
F_POWER_CHIP,
@ -172,7 +184,7 @@ enum detFuncs{
F_GET_LAST_RECEIVER_CLIENT_IP,
F_SET_RECEIVER_PORT,
F_UPDATE_RECEIVER_CLIENT,
F_GET_RECEIVER_ID,
F_GET_RECEIVER_VERSION,
F_GET_RECEIVER_TYPE,
F_SEND_RECEIVER_DETHOSTNAME,
F_RECEIVER_SET_ROI,
@ -241,8 +253,13 @@ static const char* getFunctionNameFromEnum(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";
@ -317,7 +334,14 @@ static const char* getFunctionNameFromEnum(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";
@ -400,7 +424,7 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
case F_GET_LAST_RECEIVER_CLIENT_IP: return "F_GET_LAST_RECEIVER_CLIENT_IP";
case F_SET_RECEIVER_PORT: return "F_SET_RECEIVER_PORT";
case F_UPDATE_RECEIVER_CLIENT: return "F_UPDATE_RECEIVER_CLIENT";
case F_GET_RECEIVER_ID: return "F_GET_RECEIVER_ID";
case F_GET_RECEIVER_VERSION: return "F_GET_RECEIVER_VERSION";
case F_GET_RECEIVER_TYPE: return "F_GET_RECEIVER_TYPE";
case F_SEND_RECEIVER_DETHOSTNAME: return "F_SEND_RECEIVER_DETHOSTNAME";
case F_RECEIVER_SET_ROI: return "F_RECEIVER_SET_ROI";

12
slsSupportLib/include/versionAPI.h
View File

@ -4,9 +4,9 @@
#define APIRECEIVER 0x190722
#define APIGUI 0x190723
#define APIMOENCH 0x190820
#define APIJUNGFRAU 0x191105
#define APIGOTTHARD 0x191105
#define APIGOTTHARD2 0x191105
#define APIMYTHEN3 0x191105
#define APICTB 0x191105
#define APIEIGER 0x191105
#define APICTB 0x191106
#define APIGOTTHARD2 0x191106
#define APIMYTHEN3 0x191106
#define APIJUNGFRAU 0x191106
#define APIEIGER 0x191106
#define APIGOTTHARD 0x191106