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

runs, prints right in reciever

Browse Source
This commit is contained in:
maliakal_d
2018-10-30 13:35:20 +01:00
parent 92fc837eb4
commit dfa8cf7381
32 changed files with 1058 additions and 1138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -11,7 +11,7 @@ option (USE_GUI "GUI" OFF)
if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.0) if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.0)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11 -Wno-misleading-indentation") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11 -Wno-misleading-indentation")
else () else ()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11 ")
endif () endif ()
set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address") set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address")

10
manual/manual-api/mainReceiver.cpp
View File

@ -101,15 +101,15 @@ void GetData(char* metadata, char* datapointer, uint32_t datasize, void* p){
PRINT_IN_COLOR (detectorHeader.modId?detectorHeader.modId:detectorHeader.row, PRINT_IN_COLOR (detectorHeader.modId?detectorHeader.modId:detectorHeader.row,
"#### %d GetData: ####\n" "#### %d GetData: ####\n"
"frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu" "frameNumber: %lu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %lu"
"\t\ttimestamp: %llu\t\tmodId: %u\t\t" "\t\ttimestamp: %lu\t\tmodId: %u\t\t"
"row: %u\t\tcolumn: %u\t\treserved: %u\t\tdebug: %u" "row: %u\t\tcolumn: %u\t\treserved: %u\t\tdebug: %u"
"\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u" "\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u"
//"\t\tpacketsMask:%s" //"\t\tpacketsMask:%s"
"\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n", "\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
detectorHeader.row, (long long unsigned int)detectorHeader.frameNumber, detectorHeader.row, (long unsigned int)detectorHeader.frameNumber,
detectorHeader.expLength, detectorHeader.packetNumber, (long long unsigned int)detectorHeader.bunchId, detectorHeader.expLength, detectorHeader.packetNumber, (long unsigned int)detectorHeader.bunchId,
(long long unsigned int)detectorHeader.timestamp, detectorHeader.modId, (long unsigned int)detectorHeader.timestamp, detectorHeader.modId,
detectorHeader.row, detectorHeader.column, detectorHeader.reserved, detectorHeader.row, detectorHeader.column, detectorHeader.reserved,
detectorHeader.debug, detectorHeader.roundRNumber, detectorHeader.debug, detectorHeader.roundRNumber,
detectorHeader.detType, detectorHeader.version, detectorHeader.detType, detectorHeader.version,

42
slsDetectorServers/eigerDetectorServer/Beb.c
View File

@ -134,7 +134,7 @@ void Beb_Beb(int id) {
if (!Beb_InitBebInfos()) exit(1); if (!Beb_InitBebInfos()) exit(1);
FILE_LOG(logDEBUG5, ("Printing Beb infos:\n")); FILE_LOG(logDEBUG1, ("Printing Beb infos:\n"));
unsigned int i; unsigned int i;
for(i=1;i<bebInfoSize;i++) BebInfo_Print(&beb_infos[i]); for(i=1;i<bebInfoSize;i++) BebInfo_Print(&beb_infos[i]);
@ -162,8 +162,8 @@ void Beb_GetModuleConfiguration(int* master, int* top, int* normal) {
} else { } else {
//read data //read data
ret = Beb_Read32(csp0base, MODULE_CONFIGURATION_MASK); ret = Beb_Read32(csp0base, MODULE_CONFIGURATION_MASK);
FILE_LOG(logDEBUG5, ("Module Configuration OK\n")); FILE_LOG(logDEBUG1, ("Module Configuration OK\n"));
FILE_LOG(logDEBUG5, ("Beb: value =0x%x\n",ret)); FILE_LOG(logDEBUG1, ("Beb: value =0x%x\n",ret));
if (ret&TOP_BIT_MASK) { if (ret&TOP_BIT_MASK) {
*top = 1; *top = 1;
Beb_top = 1; Beb_top = 1;
@ -228,7 +228,7 @@ void Beb_EndofDataSend(int tengiga) {
r_framepktMsbcounter = Beb_Read32(csp0base, addr_r_framepktMsbcounter); r_framepktMsbcounter = Beb_Read32(csp0base, addr_r_framepktMsbcounter);
r_txndelaycounter = Beb_Read32(csp0base, addr_r_txndelaycounter); r_txndelaycounter = Beb_Read32(csp0base, addr_r_txndelaycounter);
r_framedelaycounter = Beb_Read32(csp0base, addr_r_framedelaycounter); r_framedelaycounter = Beb_Read32(csp0base, addr_r_framedelaycounter);
FILE_LOG(logDEBUG5, ("\nLeft\n" FILE_LOG(logDEBUG1, ("\nLeft\n"
"FramepacketLsbcounter: %d\n" "FramepacketLsbcounter: %d\n"
"FramepacketMsbcounter: %d\n" "FramepacketMsbcounter: %d\n"
"Txndelaycounter:%d\n" "Txndelaycounter:%d\n"
@ -258,7 +258,7 @@ void Beb_EndofDataSend(int tengiga) {
r_framepktMsbcounter_new = Beb_Read32(csp0base, addr_r_framepktMsbcounter); r_framepktMsbcounter_new = Beb_Read32(csp0base, addr_r_framepktMsbcounter);
r_txndelaycounter_new = Beb_Read32(csp0base, addr_r_txndelaycounter); r_txndelaycounter_new = Beb_Read32(csp0base, addr_r_txndelaycounter);
r_framedelaycounter_new = Beb_Read32(csp0base, addr_r_framedelaycounter); r_framedelaycounter_new = Beb_Read32(csp0base, addr_r_framedelaycounter);
FILE_LOG(logDEBUG5, ("\nLeft\n" FILE_LOG(logDEBUG1, ("\nLeft\n"
"FramepacketLsbcounter: %d\n" "FramepacketLsbcounter: %d\n"
"FramepacketMsbcounter: %d\n" "FramepacketMsbcounter: %d\n"
"Txndelaycounter:%d\n" "Txndelaycounter:%d\n"
@ -706,10 +706,10 @@ unsigned int Beb_GetBebInfoIndex(unsigned int beb_numb) {
unsigned int i; unsigned int i;
for(i=1;i<bebInfoSize;i++) for(i=1;i<bebInfoSize;i++)
if (beb_numb==BebInfo_GetBebNumber(&beb_infos[i])) { if (beb_numb==BebInfo_GetBebNumber(&beb_infos[i])) {
FILE_LOG(logDEBUG5, ("*****found beb index:%d, for beb number:%d\n",i,beb_numb)); FILE_LOG(logDEBUG1, ("*****found beb index:%d, for beb number:%d\n",i,beb_numb));
return i; return i;
} }
FILE_LOG(logDEBUG5, ("*****Returning 0\n")); FILE_LOG(logDEBUG1, ("*****Returning 0\n"));
return 0; return 0;
} }
@ -930,11 +930,11 @@ int Beb_SendMultiReadRequest(unsigned int beb_number, unsigned int left_right, i
Beb_send_data[1] = 0x62000000 | (!stop_read_when_fifo_empty) << 27 | (ten_gig==1) << 24 | packet_size << 14 | dst_number << 8 | npackets; Beb_send_data[1] = 0x62000000 | (!stop_read_when_fifo_empty) << 27 | (ten_gig==1) << 24 | packet_size << 14 | dst_number << 8 | npackets;
FILE_LOG(logDEBUG5, ("Beb_send_data[1]:%X\n",Beb_send_data[1])); FILE_LOG(logDEBUG1, ("Beb_send_data[1]:%X\n",Beb_send_data[1]));
Beb_send_data[2] = 0; Beb_send_data[2] = 0;
Beb_SwapDataFun(0,2,&(Beb_send_data[1])); Beb_SwapDataFun(0,2,&(Beb_send_data[1]));
FILE_LOG(logDEBUG5, ("Beb_send_data[1] Swapped:%X\n",Beb_send_data[1])); FILE_LOG(logDEBUG1, ("Beb_send_data[1] Swapped:%X\n",Beb_send_data[1]));
if (Beb_activated) { if (Beb_activated) {
if (!Beb_WriteTo(i)) return 0; if (!Beb_WriteTo(i)) return 0;
@ -1004,8 +1004,8 @@ int Beb_RequestNImages(unsigned int beb_number, int ten_gig, unsigned int dst_nu
if (in_two_requests) npackets/=2; if (in_two_requests) npackets/=2;
FILE_LOG(logDEBUG5, ("----Beb_RequestNImages Start----\n")); FILE_LOG(logDEBUG1, ("----Beb_RequestNImages Start----\n"));
FILE_LOG(logDEBUG5, ("beb_number:%X, ten_gig:%X,dst_number:%X, npackets:%X, " FILE_LOG(logDEBUG1, ("beb_number:%X, ten_gig:%X,dst_number:%X, npackets:%X, "
"Beb_bit_mode:%X, header_size:%X, nimages:%d, test_just_send_out_packets_no_wait:%X\n", "Beb_bit_mode:%X, header_size:%X, nimages:%d, test_just_send_out_packets_no_wait:%X\n",
beb_number, ten_gig, dst_number, npackets, Beb_bit_mode, header_size, beb_number, ten_gig, dst_number, npackets, Beb_bit_mode, header_size,
nimages, test_just_send_out_packets_no_wait)); nimages, test_just_send_out_packets_no_wait));
@ -1051,7 +1051,7 @@ int Beb_RequestNImages(unsigned int beb_number, int ten_gig, unsigned int dst_nu
{ {
int i; int i;
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
FILE_LOG(logDEBUG5, ("%X\n",Beb_Read32(csp0base, (LEFT_OFFSET + i*4)))); FILE_LOG(logDEBUG1, ("%X\n",Beb_Read32(csp0base, (LEFT_OFFSET + i*4))));
} }
// Generating commands // Generating commands
send_header_command = 0x62000000 | (!test_just_send_out_packets_no_wait) << 27 | (ten_gig==1) << 24 | header_size << 14 | 0; send_header_command = 0x62000000 | (!test_just_send_out_packets_no_wait) << 27 | (ten_gig==1) << 24 | header_size << 14 | 0;
@ -1059,8 +1059,8 @@ int Beb_RequestNImages(unsigned int beb_number, int ten_gig, unsigned int dst_nu
{ {
int i; int i;
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
FILE_LOG(logDEBUG5, ("%X\n",Beb_Read32(csp0base, (LEFT_OFFSET + i*4)))); FILE_LOG(logDEBUG1, ("%X\n",Beb_Read32(csp0base, (LEFT_OFFSET + i*4))));
FILE_LOG(logDEBUG5, ("%d\n",in_two_requests)); FILE_LOG(logDEBUG1, ("%d\n",in_two_requests));
} }
//"0x20 << 8" is dst_number (0x00 for left, 0x20 for right) //"0x20 << 8" is dst_number (0x00 for left, 0x20 for right)
//Left //Left
@ -1088,12 +1088,12 @@ int Beb_RequestNImages(unsigned int beb_number, int ten_gig, unsigned int dst_nu
{ {
int i; int i;
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
FILE_LOG(logDEBUG5, ("%X\n",Beb_Read32(csp0base, (LEFT_OFFSET + i*4)))); //*(ptrl+i)); FILE_LOG(logDEBUG1, ("%X\n",Beb_Read32(csp0base, (LEFT_OFFSET + i*4)))); //*(ptrl+i));
FILE_LOG(logDEBUG5, ("%d\n",in_two_requests)); FILE_LOG(logDEBUG1, ("%d\n",in_two_requests));
} }
Beb_close(fd,csp0base); Beb_close(fd,csp0base);
FILE_LOG(logDEBUG5, ("----Beb_RequestNImages----\n")); FILE_LOG(logDEBUG1, ("----Beb_RequestNImages----\n"));
} }
return 1; return 1;
@ -1268,8 +1268,8 @@ int Beb_SetDetectorPosition(int pos[]) {
} }
if (ret == OK) { if (ret == OK) {
FILE_LOG(logINFO, ("Position set to...\n" FILE_LOG(logINFO, ("Position set to...\n"
"Left: [%d, %d, %d]\n" "\tLeft: [%d, %d, %d]\n"
"Right:[%d, %d, %d]\n", "\tRight:[%d, %d, %d]\n",
Beb_swap_uint16(pos[0]), Beb_top ? pos[1] : (pos[1]+1), Beb_swap_uint16(pos[2]), Beb_swap_uint16(pos[0]), Beb_top ? pos[1] : (pos[1]+1), Beb_swap_uint16(pos[2]),
Beb_swap_uint16(pos[0]), Beb_top ? (pos[1]+1) : pos[1], Beb_swap_uint16(pos[2]))); Beb_swap_uint16(pos[0]), Beb_top ? (pos[1]+1) : pos[1], Beb_swap_uint16(pos[2])));
} }
@ -1288,13 +1288,13 @@ int Beb_open(u_int32_t** csp0base, u_int32_t offset) {
if (fd == -1) { if (fd == -1) {
FILE_LOG(logERROR, ("\nCan't find /dev/mem!\n")); FILE_LOG(logERROR, ("\nCan't find /dev/mem!\n"));
} else { } else {
FILE_LOG(logDEBUG5, ("/dev/mem opened\n")); FILE_LOG(logDEBUG1, ("/dev/mem opened\n"));
*csp0base = (u_int32_t*)mmap(0, BEB_MMAP_SIZE, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, fd, offset); *csp0base = (u_int32_t*)mmap(0, BEB_MMAP_SIZE, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, fd, offset);
if (*csp0base == MAP_FAILED) { if (*csp0base == MAP_FAILED) {
FILE_LOG(logERROR, ("\nCan't map memmory area!!\n")); FILE_LOG(logERROR, ("\nCan't map memmory area!!\n"));
fd = -1; fd = -1;
} }
else FILE_LOG(logDEBUG5, ("CSP0 mapped %p\n",(void*)*csp0base)); else FILE_LOG(logDEBUG1, ("CSP0 mapped %p\n",(void*)*csp0base));
} }
return fd; return fd;
} }

46
slsDetectorServers/eigerDetectorServer/FebControl.c
View File

@ -187,7 +187,7 @@ int Feb_Control_Init(int master, int top, int normal, int module_num) {
Feb_Control_module_number = (module_num & 0xFF); Feb_Control_module_number = (module_num & 0xFF);
int serial = !top; int serial = !top;
FILE_LOG(logDEBUG5, ("serial: %d\n",serial)); FILE_LOG(logDEBUG1, ("serial: %d\n",serial));
Feb_Control_current_index = 1; Feb_Control_current_index = 1;
@ -268,7 +268,7 @@ int Feb_Control_OpenSerialCommunication() {
FILE_LOG(logERROR, ("could not write to i2c bus\n")); FILE_LOG(logERROR, ("could not write to i2c bus\n"));
return 0; return 0;
} }
FILE_LOG(logDEBUG5, ("Sent: %d bytes\n",n)); FILE_LOG(logDEBUG1, ("Sent: %d bytes\n",n));
return 1; return 1;
} }
@ -280,9 +280,9 @@ void Feb_Control_CloseSerialCommunication() {
void Feb_Control_PrintModuleList() { void Feb_Control_PrintModuleList() {
unsigned int i; unsigned int i;
FILE_LOG(logDEBUG5, ("Module list:\n")); FILE_LOG(logDEBUG1, ("Module list:\n"));
for(i=0;i<moduleSize;i++) { for(i=0;i<moduleSize;i++) {
FILE_LOG(logDEBUG5, ("\t%d) %s modules: %d 0x%x %s\n", i, FILE_LOG(logDEBUG1, ("\t%d) %s modules: %d 0x%x %s\n", i,
((i == 0) ? "All " : ((i == 1) ? "Master" : " ")), ((i == 0) ? "All " : ((i == 1) ? "Master" : " ")),
Module_GetModuleNumber(&modules[i]), Module_GetModuleNumber(&modules[i]),
(Module_TopAddressIsValid(&modules[i]) ? (Module_TopAddressIsValid(&modules[i]) ?
@ -362,19 +362,19 @@ int Feb_Control_AddModule1(unsigned int module_number, int top_enable, unsigned
if (Module_TopAddressIsValid(m)&&Module_BottomAddressIsValid(m)) { if (Module_TopAddressIsValid(m)&&Module_BottomAddressIsValid(m)) {
FILE_LOG(logDEBUG5, ("\tAdding full module number %d with top and bottom " FILE_LOG(logDEBUG1, ("\tAdding full module number %d with top and bottom "
"base addresses: %d %d\n",Module_GetModuleNumber(m), "base addresses: %d %d\n",Module_GetModuleNumber(m),
Module_GetTopBaseAddress(m),Module_GetBottomBaseAddress(m))); Module_GetTopBaseAddress(m),Module_GetBottomBaseAddress(m)));
modules[moduleSize] = mod; modules[moduleSize] = mod;
moduleSize++; moduleSize++;
} else if (Module_TopAddressIsValid(m)) { } else if (Module_TopAddressIsValid(m)) {
FILE_LOG(logDEBUG5, ("\tAdding half module number %d with " FILE_LOG(logDEBUG1, ("\tAdding half module number %d with "
"top base address: %d\n",Module_GetModuleNumber(m), "top base address: %d\n",Module_GetModuleNumber(m),
Module_GetTopBaseAddress(m))); Module_GetTopBaseAddress(m)));
modules[moduleSize] = mod; modules[moduleSize] = mod;
moduleSize++; moduleSize++;
} else if (Module_BottomAddressIsValid(m)) { } else if (Module_BottomAddressIsValid(m)) {
FILE_LOG(logDEBUG5, ("\tAdding half module number %d with " FILE_LOG(logDEBUG1, ("\tAdding half module number %d with "
"bottom base address: %d\n",Module_GetModuleNumber(m), "bottom base address: %d\n",Module_GetModuleNumber(m),
Module_GetBottomBaseAddress(m))); Module_GetBottomBaseAddress(m)));
modules[moduleSize] = mod; modules[moduleSize] = mod;
@ -389,7 +389,7 @@ int Feb_Control_AddModule1(unsigned int module_number, int top_enable, unsigned
int Feb_Control_CheckSetup(int master) { int Feb_Control_CheckSetup(int master) {
FILE_LOG(logDEBUG5, ("Checking Set up\n")); FILE_LOG(logDEBUG1, ("Checking Set up\n"));
unsigned int i,j; unsigned int i,j;
int ok = 1; int ok = 1;
@ -422,7 +422,7 @@ int Feb_Control_CheckSetup(int master) {
} }
} }
/* }*/ /* }*/
FILE_LOG(logDEBUG5, ("Done Checking Set up\n")); FILE_LOG(logDEBUG1, ("Done Checking Set up\n"));
return ok; return ok;
} }
@ -526,7 +526,7 @@ int Feb_Control_SendIDelays(unsigned int dst_num, int chip_lr, unsigned int chan
unsigned int set_right_delay_channels = chip_lr ? 0:channels; unsigned int set_right_delay_channels = chip_lr ? 0:channels;
FILE_LOG(logDEBUG5, ("\tSetting delays of %s chips of dst_num %d, " FILE_LOG(logDEBUG1, ("\tSetting delays of %s chips of dst_num %d, "
"tracks 0x%x to %d, %d clks and %d units.\n", "tracks 0x%x to %d, %d clks and %d units.\n",
((set_left_delay_channels != 0) ? "left" : "right"), ((set_left_delay_channels != 0) ? "left" : "right"),
dst_num, channels, (((15-delay_data_valid_nclks)<<6)|ndelay_units), dst_num, channels, (((15-delay_data_valid_nclks)<<6)|ndelay_units),
@ -559,7 +559,7 @@ float Feb_Control_DACToVoltage(unsigned int digital,unsigned int nsteps,float vm
//only master gets to call this function //only master gets to call this function
int Feb_Control_SetHighVoltage(int value) { int Feb_Control_SetHighVoltage(int value) {
FILE_LOG(logDEBUG5, (" Setting High Voltage:\t")); FILE_LOG(logDEBUG1, (" Setting High Voltage:\t"));
/* /*
* maximum voltage of the hv dc/dc converter: * maximum voltage of the hv dc/dc converter:
* 300 for single module power distribution board * 300 for single module power distribution board
@ -581,14 +581,14 @@ int Feb_Control_SetHighVoltage(int value) {
return -1; return -1;
} }
FILE_LOG(logINFO, ("High Voltage set to %dV\n", value)); FILE_LOG(logINFO, ("High Voltage set to %dV\n", value));
FILE_LOG(logDEBUG5, ("High Voltage set to (%d dac):\t%dV\n", dacval, value)); FILE_LOG(logDEBUG1, ("High Voltage set to (%d dac):\t%dV\n", dacval, value));
return Feb_Control_SendHighVoltage(dacval); return Feb_Control_SendHighVoltage(dacval);
} }
int Feb_Control_GetHighVoltage(int* value) { int Feb_Control_GetHighVoltage(int* value) {
FILE_LOG(logDEBUG5, (" Getting High Voltage:\t")); FILE_LOG(logDEBUG1, (" Getting High Voltage:\t"));
unsigned int dacval = 0; unsigned int dacval = 0;
if (!Feb_Control_ReceiveHighVoltage(&dacval)) if (!Feb_Control_ReceiveHighVoltage(&dacval))
@ -610,7 +610,7 @@ int Feb_Control_GetHighVoltage(int* value) {
unsigned int nsteps = ntotalsteps*vlimit/vmax; unsigned int nsteps = ntotalsteps*vlimit/vmax;
*value = (int)(Feb_Control_DACToVoltage(dacval,nsteps,vmin,vlimit)+0.5); *value = (int)(Feb_Control_DACToVoltage(dacval,nsteps,vmin,vlimit)+0.5);
FILE_LOG(logINFO, ("High Voltage read %dV\n", *value)); FILE_LOG(logINFO, ("High Voltage read %dV\n", *value));
FILE_LOG(logDEBUG5, ("High Voltage read (%d dac)\t%dV\n", dacval, *value)); FILE_LOG(logDEBUG1, ("High Voltage read (%d dac)\t%dV\n", dacval, *value));
return 1; return 1;
} }
@ -895,7 +895,7 @@ int Feb_Control_SendDACValue(unsigned int dst_num, unsigned int ch, unsigned int
float voltage=Feb_Control_DACToVoltage(*value,4096,0,2048); float voltage=Feb_Control_DACToVoltage(*value,4096,0,2048);
FILE_LOG(logINFO, ("%s set to %d (%.2fmV)\n", Module_dac_names[ch],*value,voltage)); FILE_LOG(logINFO, ("%s set to %d (%.2fmV)\n", Module_dac_names[ch],*value,voltage));
FILE_LOG(logDEBUG5, ("Dac number %d (%s) of dst %d set to %d (%f mV)\n",ch,Module_dac_names[ch],dst_num,*value,voltage)); FILE_LOG(logDEBUG1, ("Dac number %d (%s) of dst %d set to %d (%f mV)\n",ch,Module_dac_names[ch],dst_num,*value,voltage));
return 1; return 1;
} }
@ -1099,7 +1099,7 @@ int Feb_Control_AcquisitionInProgress() {
//running //running
if ((status_reg_r|status_reg_l)&DAQ_STATUS_DAQ_RUNNING) { if ((status_reg_r|status_reg_l)&DAQ_STATUS_DAQ_RUNNING) {
FILE_LOG(logDEBUG5, ("**runningggg\n")); FILE_LOG(logDEBUG1, ("**runningggg\n"));
return STATUS_RUNNING; return STATUS_RUNNING;
} }
//idle //idle
@ -1815,7 +1815,7 @@ int Feb_Control_SetRateCorrectionTau(int64_t tau_in_Nsec) {
double x = Feb_Control_rate_meas[next_i] - b*4; double x = Feb_Control_rate_meas[next_i] - b*4;
double y = next_i; double y = next_i;
/*FILE_LOG(logDEBUG5, ("Start Loop x: %f,\t y: %f,\t s: %f,\t sx: %f,\t sy: %f,\t sxx: %f,\t sxy: %f,\t " /*FILE_LOG(logDEBUG1, ("Start Loop x: %f,\t y: %f,\t s: %f,\t sx: %f,\t sy: %f,\t sxx: %f,\t sxy: %f,\t "
"next_i: %d,\t b: %d,\t Feb_Control_rate_meas[next_i]: %f\n", "next_i: %d,\t b: %d,\t Feb_Control_rate_meas[next_i]: %f\n",
x, y, s, sx, sy, sxx, sxy, next_i, b, Feb_Control_rate_meas[next_i]));*/ x, y, s, sx, sy, sxx, sxy, next_i, b, Feb_Control_rate_meas[next_i]));*/
@ -1826,7 +1826,7 @@ int Feb_Control_SetRateCorrectionTau(int64_t tau_in_Nsec) {
sy += y; sy += y;
sxx += x*x; sxx += x*x;
sxy += x*y; sxy += x*y;
/*FILE_LOG(logDEBUG5, ("End Loop x: %f,\t y: %f,\t s: %f,\t sx: %f,\t sy: %f,\t sxx: %f,\t sxy: %f,\t " /*FILE_LOG(logDEBUG1, ("End Loop x: %f,\t y: %f,\t s: %f,\t sx: %f,\t sy: %f,\t sxx: %f,\t sxy: %f,\t "
"next_i: %d,\t b: %d,\t Feb_Control_rate_meas[next_i]: %f\n", "next_i: %d,\t b: %d,\t Feb_Control_rate_meas[next_i]: %f\n",
x, y, s, sx, sy, sxx, sxy, next_i, b, Feb_Control_rate_meas[next_i]));*/ x, y, s, sx, sy, sxx, sxy, next_i, b, Feb_Control_rate_meas[next_i]));*/
} }
@ -1840,7 +1840,7 @@ int Feb_Control_SetRateCorrectionTau(int64_t tau_in_Nsec) {
if (beforemax>ratemax) b0[b] = beforemax; if (beforemax>ratemax) b0[b] = beforemax;
else b0[b] = ratemax; else b0[b] = ratemax;
} }
/*FILE_LOG(logDEBUG5, ("After Loop s: %f,\t sx: %f,\t sy: %f,\t sxx: %f,\t sxy: %f,\t " /*FILE_LOG(logDEBUG1, ("After Loop s: %f,\t sx: %f,\t sy: %f,\t sxx: %f,\t sxy: %f,\t "
"next_i: %d,\t b: %d,\t Feb_Control_rate_meas[next_i]: %f\n", "next_i: %d,\t b: %d,\t Feb_Control_rate_meas[next_i]: %f\n",
s, sx, sy, sxx, sxy, next_i, b, Feb_Control_rate_meas[next_i]));*/ s, sx, sy, sxx, sxy, next_i, b, Feb_Control_rate_meas[next_i]));*/
// cout<<s<<" "<<sx<<" "<<sy<<" "<<sxx<<" "<<" "<<sxy<<" "<<delta<<" "<<m[b]<<" "<<b0[b]<<endl; // cout<<s<<" "<<sx<<" "<<sy<<" "<<sxx<<" "<<" "<<sxy<<" "<<delta<<" "<<m[b]<<" "<<b0[b]<<endl;
@ -1850,7 +1850,7 @@ int Feb_Control_SetRateCorrectionTau(int64_t tau_in_Nsec) {
m[b] = 15; m[b] = 15;
} }
Feb_Control_rate_correction_table[b] = (((int)(m[b]+0.5)&0xf)<<14) | ((int)(b0[b]+0.5)&0x3fff); Feb_Control_rate_correction_table[b] = (((int)(m[b]+0.5)&0xf)<<14) | ((int)(b0[b]+0.5)&0x3fff);
/*FILE_LOG(logDEBUG5, ("After Loop 4*b: %d\tbase:%d\tslope:%d\n",4*b, (int)(b0[b]+0.5), (int)(m[b]+0.5) ));*/ /*FILE_LOG(logDEBUG1, ("After Loop 4*b: %d\tbase:%d\tslope:%d\n",4*b, (int)(b0[b]+0.5), (int)(m[b]+0.5) ));*/
} }
if (Feb_Control_SetRateCorrectionTable(Feb_Control_rate_correction_table)) { if (Feb_Control_SetRateCorrectionTable(Feb_Control_rate_correction_table)) {
@ -1936,7 +1936,7 @@ int Feb_Control_PrintCorrectedValues() {
corr = delta+base; corr = delta+base;
if (slope==15) corr= 3*slope+base; if (slope==15) corr= 3*slope+base;
FILE_LOG(logDEBUG5, ("Readout Input: %d,\tBase:%d,\tSlope:%d,\tLSB:%d,\tDelta:%d\tResult:%d\tReal:%lf\n", FILE_LOG(logDEBUG1, ("Readout Input: %d,\tBase:%d,\tSlope:%d,\tLSB:%d,\tDelta:%d\tResult:%d\tReal:%lf\n",
i, base, slope, lsb, delta, corr, Feb_Control_rate_meas[i])); i, base, slope, lsb, delta, corr, Feb_Control_rate_meas[i]));
} }
return 1; return 1;
@ -1999,13 +1999,13 @@ int Feb_Control_SoftwareTrigger() {
if (Feb_Control_activated) { if (Feb_Control_activated) {
// set trigger bit // set trigger bit
FILE_LOG(logDEBUG5, ("Setting Trigger, Register:0x%x\n",cmd)); FILE_LOG(logDEBUG1, ("Setting Trigger, Register:0x%x\n",cmd));
if (!Feb_Interface_WriteRegister(Feb_Control_AddressToAll(),DAQ_REG_CHIP_CMDS,cmd,0,0)) { if (!Feb_Interface_WriteRegister(Feb_Control_AddressToAll(),DAQ_REG_CHIP_CMDS,cmd,0,0)) {
FILE_LOG(logERROR, ("Could not give software trigger\n")); FILE_LOG(logERROR, ("Could not give software trigger\n"));
return 0; return 0;
} }
// unset trigger bit // unset trigger bit
FILE_LOG(logDEBUG5, ("Unsetting Trigger, Register:0x%x\n",orig_value)); FILE_LOG(logDEBUG1, ("Unsetting Trigger, Register:0x%x\n",orig_value));
if (!Feb_Interface_WriteRegister(Feb_Control_AddressToAll(),DAQ_REG_CHIP_CMDS,orig_value,0,0)) { if (!Feb_Interface_WriteRegister(Feb_Control_AddressToAll(),DAQ_REG_CHIP_CMDS,orig_value,0,0)) {
FILE_LOG(logERROR, ("Could not give software trigger\n")); FILE_LOG(logERROR, ("Could not give software trigger\n"));
return 0; return 0;

2
slsDetectorServers/eigerDetectorServer/FebInterface.c
View File

@ -57,7 +57,7 @@ void Feb_Interface_SendCompleteList(unsigned int n,unsigned int* list) {
int Feb_Interface_WriteTo(unsigned int ch) { int Feb_Interface_WriteTo(unsigned int ch) {
if (ch>0xfff) return 0; if (ch>0xfff) return 0;
FILE_LOG(logDEBUG5, ("FIW ch %d\n", ch)); FILE_LOG(logDEBUG1, ("FIW ch %d\n", ch));
Feb_Interface_send_data_raw[0] = 0x8fff0000; Feb_Interface_send_data_raw[0] = 0x8fff0000;
if (Local_Write(ll,4,Feb_Interface_send_data_raw)!=4) return 0; if (Local_Write(ll,4,Feb_Interface_send_data_raw)!=4) return 0;

20
slsDetectorServers/eigerDetectorServer/LocalLinkInterface.c
View File

@ -10,18 +10,18 @@
void Local_LocalLinkInterface1(struct LocalLinkInterface* ll,unsigned int ll_fifo_badr) { void Local_LocalLinkInterface1(struct LocalLinkInterface* ll,unsigned int ll_fifo_badr) {
FILE_LOG(logDEBUG5, ("Initialize PLB LL FIFOs\n")); FILE_LOG(logDEBUG1, ("Initialize PLB LL FIFOs\n"));
ll->ll_fifo_base=0; ll->ll_fifo_base=0;
ll->ll_fifo_ctrl_reg=0; ll->ll_fifo_ctrl_reg=0;
if (Local_Init(ll,ll_fifo_badr)) { if (Local_Init(ll,ll_fifo_badr)) {
Local_Reset(ll); Local_Reset(ll);
FILE_LOG(logDEBUG5, ("\tFIFO Status : 0x%08x\n\n\n", Local_StatusVector(ll))); FILE_LOG(logDEBUG1, ("\tFIFO Status : 0x%08x\n\n\n", Local_StatusVector(ll)));
} else FILE_LOG(logERROR, ("\tCould not map LocalLink : 0x%08x\n\n\n", ll_fifo_badr)); } else FILE_LOG(logERROR, ("\tCould not map LocalLink : 0x%08x\n\n\n", ll_fifo_badr));
} }
void Local_LocalLinkInterface(struct LocalLinkInterface* ll) { void Local_LocalLinkInterface(struct LocalLinkInterface* ll) {
FILE_LOG(logDEBUG5, ("Initializing new memory\n")); FILE_LOG(logDEBUG1, ("Initializing new memory\n"));
} }
@ -57,7 +57,7 @@ int Local_Reset(struct LocalLinkInterface* ll) {
int Local_Reset1(struct LocalLinkInterface* ll,unsigned int rst_mask) { int Local_Reset1(struct LocalLinkInterface* ll,unsigned int rst_mask) {
ll->ll_fifo_ctrl_reg |= rst_mask; ll->ll_fifo_ctrl_reg |= rst_mask;
FILE_LOG(logDEBUG5, ("\tCTRL Register bits: 0x%08x\n",ll->ll_fifo_ctrl_reg)); FILE_LOG(logDEBUG1, ("\tCTRL Register bits: 0x%08x\n",ll->ll_fifo_ctrl_reg));
HWIO_xfs_out32(ll->ll_fifo_base+4*PLB_LL_FIFO_REG_CTRL,ll->ll_fifo_ctrl_reg); HWIO_xfs_out32(ll->ll_fifo_base+4*PLB_LL_FIFO_REG_CTRL,ll->ll_fifo_ctrl_reg);
HWIO_xfs_out32(ll->ll_fifo_base+4*PLB_LL_FIFO_REG_CTRL,ll->ll_fifo_ctrl_reg); HWIO_xfs_out32(ll->ll_fifo_base+4*PLB_LL_FIFO_REG_CTRL,ll->ll_fifo_ctrl_reg);
@ -92,9 +92,9 @@ int Local_Write(struct LocalLinkInterface* ll,unsigned int buffer_len, void *buf
last_word = (buffer_len-1)/4; last_word = (buffer_len-1)/4;
word_ptr = (unsigned int *)buffer; word_ptr = (unsigned int *)buffer;
FILE_LOG(logDEBUG5, ("LL Write - Len: %2d - If: %X - Data: ",buffer_len, ll->ll_fifo_base)); FILE_LOG(logDEBUG1, ("LL Write - Len: %2d - If: %X - Data: ",buffer_len, ll->ll_fifo_base));
for (i=0; i < buffer_len/4; i++) for (i=0; i < buffer_len/4; i++)
FILE_LOG(logDEBUG5, ("%.8X ",*(((unsigned *) buffer)+i))); FILE_LOG(logDEBUG1, ("%.8X ",*(((unsigned *) buffer)+i)));
while (words_send <= last_word) while (words_send <= last_word)
{ {
@ -138,7 +138,7 @@ int Local_Read(struct LocalLinkInterface* ll,unsigned int buffer_len, void *buff
volatile unsigned int fifo_val; volatile unsigned int fifo_val;
int sof = 0; int sof = 0;
FILE_LOG(logDEBUG5, ("LL Read - If: %X - Data: ",ll->ll_fifo_base)); FILE_LOG(logDEBUG1, ("LL Read - If: %X - Data: ",ll->ll_fifo_base));
word_ptr = (unsigned int *)buffer; word_ptr = (unsigned int *)buffer;
do do
@ -164,7 +164,7 @@ int Local_Read(struct LocalLinkInterface* ll,unsigned int buffer_len, void *buff
{ {
if ( (buffer_len >> 2) > buffer_ptr) if ( (buffer_len >> 2) > buffer_ptr)
{ {
FILE_LOG(logDEBUG5, ("%.8X ", fifo_val)); FILE_LOG(logDEBUG1, ("%.8X ", fifo_val));
word_ptr[buffer_ptr++] = fifo_val; //write to buffer word_ptr[buffer_ptr++] = fifo_val; //write to buffer
} }
else else
@ -176,7 +176,7 @@ int Local_Read(struct LocalLinkInterface* ll,unsigned int buffer_len, void *buff
if (status & PLB_LL_FIFO_STATUS_LL_EOF) if (status & PLB_LL_FIFO_STATUS_LL_EOF)
{ {
len = (buffer_ptr << 2) -3 + ( (status & PLB_LL_FIFO_STATUS_LL_REM)>>PLB_LL_FIFO_STATUS_LL_REM_SHIFT ); len = (buffer_ptr << 2) -3 + ( (status & PLB_LL_FIFO_STATUS_LL_REM)>>PLB_LL_FIFO_STATUS_LL_REM_SHIFT );
FILE_LOG(logDEBUG5, ("Len: %d\n",len)); FILE_LOG(logDEBUG1, ("Len: %d\n",len));
buffer_ptr = 0; buffer_ptr = 0;
return len; return len;
} }
@ -209,7 +209,7 @@ int Local_Test(struct LocalLinkInterface* ll,unsigned int buffer_len, void *buff
do{ do{
len = Local_Read(ll,rec_buff_len,rec_buffer); len = Local_Read(ll,rec_buff_len,rec_buffer);
FILE_LOG(logDEBUG5, ("receive length: %i\n",len)); FILE_LOG(logDEBUG1, ("receive length: %i\n",len));
if (len > 0) { if (len > 0) {
rec_buffer[len]=0; rec_buffer[len]=0;

8
slsDetectorServers/eigerDetectorServer/gitInfo.txt
View File

@ -1,9 +1,9 @@
Path: slsDetectorPackage/slsDetectorServers/eigerDetectorServer Path: slsDetectorPackage/slsDetectorServers/eigerDetectorServer
URL: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git URL: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git
Repository Root: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git Repository Root: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git
Repsitory UUID: dfad145e1492e961c95063aa5b2f54e5e1b418a0 Repsitory UUID: 92fc837eb490650d91c2283943cbd729b2e36567
Revision: 3 Revision: 6
Branch: refactor Branch: refactor
Last Changed Author: Dhanya_Thattil Last Changed Author: Dhanya_Thattil
Last Changed Rev: 4127 Last Changed Rev: 4131
Last Changed Date: 2018-10-23 12:30:26.000000002 +0200 ./Beb.c Last Changed Date: 2018-10-29 17:14:27.000000002 +0100 ./Beb.c

6
slsDetectorServers/eigerDetectorServer/gitInfoEiger.h
View File

@ -1,6 +1,6 @@
#define GITURL "git@github.com:slsdetectorgroup/slsDetectorPackage.git" #define GITURL "git@github.com:slsdetectorgroup/slsDetectorPackage.git"
#define GITREPUUID "dfad145e1492e961c95063aa5b2f54e5e1b418a0" #define GITREPUUID "92fc837eb490650d91c2283943cbd729b2e36567"
#define GITAUTH "Dhanya_Thattil" #define GITAUTH "Dhanya_Thattil"
#define GITREV 0x4127 #define GITREV 0x4131
#define GITDATE 0x20181023 #define GITDATE 0x20181029
#define GITBRANCH "refactor" #define GITBRANCH "refactor"

74
slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -306,10 +306,10 @@ void initControlServer() {
if (Feb_Control_OpenSerialCommunication()) if (Feb_Control_OpenSerialCommunication())
;// Feb_Control_CloseSerialCommunication(); ;// Feb_Control_CloseSerialCommunication();
} }
FILE_LOG(logDEBUG5, ("Control server: FEB Initialization done\n")); FILE_LOG(logDEBUG1, ("Control server: FEB Initialization done\n"));
Beb_Beb(detid); Beb_Beb(detid);
Beb_SetDetectorNumber(getDetectorNumber()); Beb_SetDetectorNumber(getDetectorNumber());
FILE_LOG(logDEBUG5, ("Control server: BEB Initialization done\n")); FILE_LOG(logDEBUG1, ("Control server: BEB Initialization done\n"));
setupDetector(); setupDetector();
@ -325,7 +325,7 @@ void initStopServer() {
Feb_Interface_FebInterface(); Feb_Interface_FebInterface();
Feb_Control_FebControl(); Feb_Control_FebControl();
Feb_Control_Init(master,top,normal,getDetectorNumber()); Feb_Control_Init(master,top,normal,getDetectorNumber());
FILE_LOG(logDEBUG5, ("Stop server: FEB Initialization done\n")); FILE_LOG(logDEBUG1, ("Stop server: FEB Initialization done\n"));
#endif #endif
} }
@ -385,10 +385,10 @@ void allocateDetectorStructureMemory() {
detectorChans=malloc(NCHIP*NCHAN*sizeof(int)); detectorChans=malloc(NCHIP*NCHAN*sizeof(int));
detectorDacs=malloc(NDAC*sizeof(int)); detectorDacs=malloc(NDAC*sizeof(int));
detectorAdcs=malloc(NADC*sizeof(int)); detectorAdcs=malloc(NADC*sizeof(int));
FILE_LOG(logDEBUG5, ("modules from 0x%x to 0x%x\n",detectorModules, detectorModules)); FILE_LOG(logDEBUG1, ("modules from 0x%x to 0x%x\n",detectorModules, detectorModules));
FILE_LOG(logDEBUG5, ("chans from 0x%x to 0x%x\n",detectorChans, detectorChans)); FILE_LOG(logDEBUG1, ("chans from 0x%x to 0x%x\n",detectorChans, detectorChans));
FILE_LOG(logDEBUG5, ("dacs from 0x%x to 0x%x\n",detectorDacs, detectorDacs)); FILE_LOG(logDEBUG1, ("dacs from 0x%x to 0x%x\n",detectorDacs, detectorDacs));
FILE_LOG(logDEBUG5, ("adcs from 0x%x to 0x%x\n",detectorAdcs, detectorAdcs)); FILE_LOG(logDEBUG1, ("adcs from 0x%x to 0x%x\n",detectorAdcs, detectorAdcs));
(detectorModules)->dacs=detectorDacs; (detectorModules)->dacs=detectorDacs;
(detectorModules)->adcs=detectorAdcs; (detectorModules)->adcs=detectorAdcs;
(detectorModules)->chanregs=detectorChans; (detectorModules)->chanregs=detectorChans;
@ -455,7 +455,7 @@ void setupDetector() {
#ifndef VIRTUAL #ifndef VIRTUAL
Feb_Control_CheckSetup(); Feb_Control_CheckSetup();
#endif #endif
FILE_LOG(logDEBUG5, ("Setup detector done\n\n")); FILE_LOG(logDEBUG1, ("Setup detector done\n\n"));
} }
@ -491,7 +491,7 @@ int setDynamicRange(int dr) {
return eiger_dynamicrange; return eiger_dynamicrange;
#else #else
if (dr > 0) { if (dr > 0) {
FILE_LOG(logDEBUG5, ("Setting dynamic range: %d\n", dr)); FILE_LOG(logDEBUG1, ("Setting dynamic range: %d\n", dr));
if (Feb_Control_SetDynamicRange(dr)) { if (Feb_Control_SetDynamicRange(dr)) {
//EigerSetBitMode(dr); //EigerSetBitMode(dr);
@ -518,7 +518,7 @@ int setDynamicRange(int dr) {
enum speedVariable setSpeed(int val) { enum speedVariable setSpeed(int val) {
if (val != -1) { if (val != -1) {
FILE_LOG(logDEBUG5, ("Setting Read out Speed: %d\n", val)); FILE_LOG(logDEBUG1, ("Setting Read out Speed: %d\n", val));
#ifndef VIRTUAL #ifndef VIRTUAL
if (Feb_Control_SetReadoutSpeed(val)) if (Feb_Control_SetReadoutSpeed(val))
#endif #endif
@ -538,15 +538,15 @@ enum readOutFlags setReadOutFlags(enum readOutFlags val) {
switch(val) { switch(val) {
case PARALLEL: case PARALLEL:
val=E_PARALLEL; val=E_PARALLEL;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: Parallel\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: Parallel\n"));
break; break;
case NONPARALLEL: case NONPARALLEL:
val=E_NON_PARALLEL; val=E_NON_PARALLEL;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: Non Parallel\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: Non Parallel\n"));
break; break;
case SAFE: case SAFE:
val=E_SAFE; val=E_SAFE;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: Safe\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: Safe\n"));
break; break;
default: default:
@ -567,11 +567,11 @@ enum readOutFlags setReadOutFlags(enum readOutFlags val) {
switch(val) { switch(val) {
case SHOW_OVERFLOW: case SHOW_OVERFLOW:
val=1; val=1;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: Overflow in 32 bit mode\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: Overflow in 32 bit mode\n"));
break; break;
case NOOVERFLOW: case NOOVERFLOW:
val=0; val=0;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: No overflow in 32 bit mode\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: No overflow in 32 bit mode\n"));
break; break;
default: default:
FILE_LOG(logERROR, ("Cannot set unknown readout flag. 0x%x\n", val)); FILE_LOG(logERROR, ("Cannot set unknown readout flag. 0x%x\n", val));
@ -591,11 +591,11 @@ enum readOutFlags setReadOutFlags(enum readOutFlags val) {
switch(val) { switch(val) {
case STORE_IN_RAM: case STORE_IN_RAM:
val=1; val=1;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: Store in Ram\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: Store in Ram\n"));
break; break;
case CONTINOUS_RO: case CONTINOUS_RO:
val=0; val=0;
FILE_LOG(logDEBUG5, ("Setting Read out Flag: Continuous Readout\n")); FILE_LOG(logDEBUG1, ("Setting Read out Flag: Continuous Readout\n"));
break; break;
default: default:
@ -638,7 +638,7 @@ enum readOutFlags setReadOutFlags(enum readOutFlags val) {
break; break;
} }
FILE_LOG(logDEBUG5, ("Read out Flag: 0x%x\n", retval)); FILE_LOG(logDEBUG1, ("Read out Flag: 0x%x\n", retval));
return retval; return retval;
} }
@ -659,7 +659,7 @@ int64_t setTimer(enum timerIndex ind, int64_t val) {
switch(ind) { switch(ind) {
case FRAME_NUMBER: case FRAME_NUMBER:
if (val >= 0) { if (val >= 0) {
FILE_LOG(logDEBUG5, ("Setting number of frames: %d * %d\n", (unsigned int)val, eiger_ncycles)); FILE_LOG(logDEBUG1, ("Setting number of frames: %d * %d\n", (unsigned int)val, eiger_ncycles));
#ifndef VIRTUAL #ifndef VIRTUAL
if (Feb_Control_SetNExposures((unsigned int)val*eiger_ncycles)) { if (Feb_Control_SetNExposures((unsigned int)val*eiger_ncycles)) {
eiger_nexposures = val; eiger_nexposures = val;
@ -678,7 +678,7 @@ int64_t setTimer(enum timerIndex ind, int64_t val) {
case ACQUISITION_TIME: case ACQUISITION_TIME:
if (val >= 0) { if (val >= 0) {
FILE_LOG(logDEBUG5, ("Setting exp time: %fs\n", val/(1E9))); FILE_LOG(logDEBUG1, ("Setting exp time: %fs\n", val/(1E9)));
#ifndef VIRTUAL #ifndef VIRTUAL
Feb_Control_SetExposureTime(val/(1E9)); Feb_Control_SetExposureTime(val/(1E9));
#else #else
@ -693,7 +693,7 @@ int64_t setTimer(enum timerIndex ind, int64_t val) {
case SUBFRAME_ACQUISITION_TIME: case SUBFRAME_ACQUISITION_TIME:
if (val >= 0) { if (val >= 0) {
FILE_LOG(logDEBUG5, ("Setting sub exp time: %lldns\n", (long long int)val)); FILE_LOG(logDEBUG1, ("Setting sub exp time: %lldns\n", (long long int)val));
#ifndef VIRTUAL #ifndef VIRTUAL
// calculate subdeadtime before settings subexptime // calculate subdeadtime before settings subexptime
subdeadtime = Feb_Control_GetSubFramePeriod() - subdeadtime = Feb_Control_GetSubFramePeriod() -
@ -743,7 +743,7 @@ int64_t setTimer(enum timerIndex ind, int64_t val) {
case FRAME_PERIOD: case FRAME_PERIOD:
if (val >= 0) { if (val >= 0) {
FILE_LOG(logDEBUG5, ("Setting acq period: %fs\n", val/(1E9))); FILE_LOG(logDEBUG1, ("Setting acq period: %fs\n", val/(1E9)));
#ifndef VIRTUAL #ifndef VIRTUAL
Feb_Control_SetExposurePeriod(val/(1E9)); Feb_Control_SetExposurePeriod(val/(1E9));
#else #else
@ -758,7 +758,7 @@ int64_t setTimer(enum timerIndex ind, int64_t val) {
case CYCLES_NUMBER: case CYCLES_NUMBER:
if (val >= 0) { if (val >= 0) {
FILE_LOG(logDEBUG5, ("Setting number of triggers: %d * %d\n", FILE_LOG(logDEBUG1, ("Setting number of triggers: %d * %d\n",
(unsigned int)val,eiger_nexposures)); (unsigned int)val,eiger_nexposures));
#ifndef VIRTUAL #ifndef VIRTUAL
if (Feb_Control_SetNExposures((unsigned int)val*eiger_nexposures)) { if (Feb_Control_SetNExposures((unsigned int)val*eiger_nexposures)) {
@ -1005,7 +1005,7 @@ int setThresholdEnergy(int ev) {
/* parameters - dac, adc, hv */ /* parameters - dac, adc, hv */
void setDAC(enum DACINDEX ind, int val, int mV, int retval[]) { void setDAC(enum DACINDEX ind, int val, int mV, int retval[]) {
FILE_LOG(logDEBUG5, ("Going to set dac %d to %d with mv mode %d \n", (int)ind, val, mV)); FILE_LOG(logDEBUG1, ("Going to set dac %d to %d with mv mode %d \n", (int)ind, val, mV));
if (ind == VTHRESHOLD) { if (ind == VTHRESHOLD) {
int ret[5]; int ret[5];
setDAC(VCMP_LL,val,mV,retval); setDAC(VCMP_LL,val,mV,retval);
@ -1040,7 +1040,7 @@ void setDAC(enum DACINDEX ind, int val, int mV, int retval[]) {
FILE_LOG(logINFO, ("dac value outside range:%d\n",(int)ind)); FILE_LOG(logINFO, ("dac value outside range:%d\n",(int)ind));
strcpy(iname,dac_names[0]); strcpy(iname,dac_names[0]);
} }
FILE_LOG(logDEBUG5, ("%s dac %d: %s to %d %s\n", FILE_LOG(logDEBUG1, ("%s dac %d: %s to %d %s\n",
(val >= 0) ? "Setting" : "Getting", (val >= 0) ? "Setting" : "Getting",
ind, iname, val, ind, iname, val,
mV ? "mV" : "dac units")); mV ? "mV" : "dac units"));
@ -1166,7 +1166,7 @@ void setTiming( enum externalCommunicationMode arg) {
case BURST_TRIGGER: ret = 1; break; case BURST_TRIGGER: ret = 1; break;
case GATE_FIX_NUMBER: ret = 3; break; case GATE_FIX_NUMBER: ret = 3; break;
} }
FILE_LOG(logDEBUG5, ("Setting Triggering Mode: %d\n", (int)ret)); FILE_LOG(logDEBUG1, ("Setting Triggering Mode: %d\n", (int)ret));
#ifndef VIRTUAL #ifndef VIRTUAL
if (Feb_Control_SetTriggerMode(ret,1)) if (Feb_Control_SetTriggerMode(ret,1))
#endif #endif
@ -1216,10 +1216,10 @@ int configureMAC(uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t
FILE_LOG(logINFO, ("src_port:%d\n" FILE_LOG(logINFO, ("src_port:%d\n"
"src_ip:%s\n" "\tsrc_ip:%s\n"
"dst_ip:%s\n" "\tdst_ip:%s\n"
"src_mac:%s\n" "\tsrc_mac:%s\n"
"dst_mac:%s\n", "\tdst_mac:%s\n",
src_port, src_ip, dst_ip, src_mac, dst_mac)); src_port, src_ip, dst_ip, src_mac, dst_mac));
@ -1229,7 +1229,7 @@ int configureMAC(uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t
if (!top) if (!top)
dst_port = udpport2; dst_port = udpport2;
FILE_LOG(logINFO, ("dst_port:%d\n", dst_port)); FILE_LOG(logINFO, ("\tdst_port:%d\n", dst_port));
int i=0; int i=0;
/* for(i=0;i<32;i++) { modified for Aldo*/ /* for(i=0;i<32;i++) { modified for Aldo*/
@ -1282,7 +1282,7 @@ int setDetectorPosition(int pos[]) {
int setIODelay(int val) { int setIODelay(int val) {
if (val!=-1) { if (val!=-1) {
FILE_LOG(logDEBUG5, ("Setting IO Delay: %d\n",val)); FILE_LOG(logDEBUG1, ("Setting IO Delay: %d\n",val));
#ifndef VIRTUAL #ifndef VIRTUAL
if (Feb_Control_SetIDelays(Feb_Control_GetModuleNumber(),val)) if (Feb_Control_SetIDelays(Feb_Control_GetModuleNumber(),val))
#endif #endif
@ -1788,7 +1788,7 @@ int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) {
int idac, ichan, iadc; int idac, ichan, iadc;
int ret=OK; int ret=OK;
FILE_LOG(logDEBUG5, ("Copying module %x to module %x\n",srcMod,destMod)); FILE_LOG(logDEBUG1, ("Copying module %x to module %x\n",srcMod,destMod));
if (srcMod->serialnumber>=0) { if (srcMod->serialnumber>=0) {
@ -1808,9 +1808,9 @@ int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) {
return FAIL; return FAIL;
} }
FILE_LOG(logDEBUG5, ("DACs: src %d, dest %d\n",srcMod->ndac,destMod->ndac)); FILE_LOG(logDEBUG1, ("DACs: src %d, dest %d\n",srcMod->ndac,destMod->ndac));
FILE_LOG(logDEBUG5, ("ADCs: src %d, dest %d\n",srcMod->nadc,destMod->nadc)); FILE_LOG(logDEBUG1, ("ADCs: src %d, dest %d\n",srcMod->nadc,destMod->nadc));
FILE_LOG(logDEBUG5, ("Chans: src %d, dest %d\n",srcMod->nchan,destMod->nchan)); FILE_LOG(logDEBUG1, ("Chans: src %d, dest %d\n",srcMod->nchan,destMod->nchan));
destMod->ndac=srcMod->ndac; destMod->ndac=srcMod->ndac;
destMod->nadc=srcMod->nadc; destMod->nadc=srcMod->nadc;
destMod->nchip=srcMod->nchip; destMod->nchip=srcMod->nchip;
@ -1823,7 +1823,7 @@ int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) {
destMod->tau=srcMod->tau; destMod->tau=srcMod->tau;
if (srcMod->eV>=0) if (srcMod->eV>=0)
destMod->eV=srcMod->eV; destMod->eV=srcMod->eV;
FILE_LOG(logDEBUG5, ("Copying register %x (%x)\n",destMod->reg,srcMod->reg )); FILE_LOG(logDEBUG1, ("Copying register %x (%x)\n",destMod->reg,srcMod->reg ));
if (destMod->nchan!=0) { if (destMod->nchan!=0) {
for (ichan=0; ichan<(srcMod->nchan); ichan++) { for (ichan=0; ichan<(srcMod->nchan); ichan++) {

18
slsDetectorServers/slsDetectorServer/communication_funcs.c
View File

@ -95,7 +95,7 @@ int bindSocket(unsigned short int port_number) {
// success // success
myport = port_number; myport = port_number;
ret = OK; ret = OK;
FILE_LOG(logDEBUG5, ("%s socket bound: isock=%d, port=%d, fd=%d\n", FILE_LOG(logDEBUG1, ("%s socket bound: isock=%d, port=%d, fd=%d\n",
(isControlServer ? "Control":"Stop"), isock, port_number, socketDescriptor)); (isControlServer ? "Control":"Stop"), isock, port_number, socketDescriptor));
} }
@ -136,7 +136,7 @@ int acceptConnection(int socketDescriptor) {
// timeout // timeout
if (result == 0) { if (result == 0) {
FILE_LOG(logDEBUG5, ("%s socket select() timed out!\n", FILE_LOG(logDEBUG1, ("%s socket select() timed out!\n",
(isControlServer ? "control":"stop"), myport)); (isControlServer ? "control":"stop"), myport));
} }
@ -148,14 +148,14 @@ int acceptConnection(int socketDescriptor) {
// activity in descriptor set // activity in descriptor set
else if (result > 0) { else if (result > 0) {
FILE_LOG(logDEBUG5, ("%s select returned!\n", (isControlServer ? "control":"stop"))); FILE_LOG(logDEBUG1, ("%s select returned!\n", (isControlServer ? "control":"stop")));
// loop through the file descriptor set // loop through the file descriptor set
for (j = 0; j < maxfd + 1; ++j) { for (j = 0; j < maxfd + 1; ++j) {
// checks if file descriptor part of set // checks if file descriptor part of set
if (FD_ISSET(j, &tempset)) { if (FD_ISSET(j, &tempset)) {
FILE_LOG(logDEBUG5, ("fd %d is set\n",j)); FILE_LOG(logDEBUG1, ("fd %d is set\n",j));
// clear the temporary set // clear the temporary set
FD_CLR(j, &tempset); FD_CLR(j, &tempset);
@ -216,7 +216,7 @@ int acceptConnection(int socketDescriptor) {
// accept success // accept success
else { else {
inet_ntop(AF_INET, &(addressC.sin_addr), dummyClientIP, INET_ADDRSTRLEN); inet_ntop(AF_INET, &(addressC.sin_addr), dummyClientIP, INET_ADDRSTRLEN);
FILE_LOG(logDEBUG5, ("%s socket accepted connection, fd= %d\n", FILE_LOG(logDEBUG1, ("%s socket accepted connection, fd= %d\n",
(isControlServer ? "control":"stop"), file_des)); (isControlServer ? "control":"stop"), file_des));
// add the file descriptor from accept // add the file descriptor from accept
FD_SET(file_des, &readset); FD_SET(file_des, &readset);
@ -244,7 +244,7 @@ void closeConnection(int file_des) {
void exitServer(int socketDescriptor) { void exitServer(int socketDescriptor) {
if (socketDescriptor >= 0) if (socketDescriptor >= 0)
close(socketDescriptor); close(socketDescriptor);
FILE_LOG(logDEBUG5, ("Closing %s server\n", (isControlServer ? "control":"stop"))); FILE_LOG(logDEBUG1, ("Closing %s server\n", (isControlServer ? "control":"stop")));
FD_CLR(socketDescriptor, &readset); FD_CLR(socketDescriptor, &readset);
isock--; isock--;
} }
@ -320,7 +320,7 @@ int receiveDataOnly(int file_des, void* buf,int length) {
int nreceiving; int nreceiving;
int nreceived; int nreceived;
if (file_des<0) return -1; if (file_des<0) return -1;
FILE_LOG(logDEBUG5, ("want to receive %d Bytes to %s server\n", FILE_LOG(logDEBUG1, ("want to receive %d Bytes to %s server\n",
length, (isControlServer ? "control":"stop"))); length, (isControlServer ? "control":"stop")));
while(length > 0) { while(length > 0) {
@ -381,7 +381,7 @@ int sendModule(int file_des, sls_detector_module *myMod) {
n = sendData(file_des,myMod->chanregs, sizeof(int) * (myMod->nchan), INT32); n = sendData(file_des,myMod->chanregs, sizeof(int) * (myMod->nchan), INT32);
if (!n) return -1; ts += n; if (!n) return -1; ts += n;
#endif #endif
FILE_LOG(logDEBUG5, ("module of size %d sent register %x\n", ts, myMod->reg)); FILE_LOG(logDEBUG1, ("module of size %d sent register %x\n", ts, myMod->reg));
return ts; return ts;
} }
@ -439,7 +439,7 @@ int receiveModule(int file_des, sls_detector_module* myMod) {
n = receiveData(file_des,&(myMod->chanregs), sizeof(int) * (myMod->nchan), INT32); n = receiveData(file_des,&(myMod->chanregs), sizeof(int) * (myMod->nchan), INT32);
if (!n) return -1; ts += n; if (!n) return -1; ts += n;
#endif #endif
FILE_LOG(logDEBUG5, ("received module of size %d register %x\n",ts,myMod->reg)); FILE_LOG(logDEBUG1, ("received module of size %d register %x\n",ts,myMod->reg));
return ts; return ts;
} }

2
slsDetectorServers/slsDetectorServer/slsDetectorServer.c
View File

@ -72,7 +72,7 @@ int main(int argc, char *argv[]){
for (i = 0; i < argc; ++i) for (i = 0; i < argc; ++i)
sprintf(cmd, "%s %s", cmd, argv[i]); sprintf(cmd, "%s %s", cmd, argv[i]);
sprintf(cmd,"%s -stopserver&", cmd); sprintf(cmd,"%s -stopserver&", cmd);
FILE_LOG(logDEBUG5, ("Command to start stop server:%s\n", cmd)); FILE_LOG(logDEBUG1, ("Command to start stop server:%s\n", cmd));
system(cmd); system(cmd);
} }
#endif #endif

253
slsDetectorServers/slsDetectorServer/slsDetectorServer_funcs.c
View File

@ -84,11 +84,11 @@ int decode_function(int file_des) {
int n = receiveData(file_des,&fnum,sizeof(fnum),INT32); int n = receiveData(file_des,&fnum,sizeof(fnum),INT32);
if (n <= 0) { if (n <= 0) {
FILE_LOG(logDEBUG5, ("ERROR reading from socket n=%d, fnum=%d, file_des=%d, fname=%s\n", FILE_LOG(logDEBUG3, ("ERROR reading from socket n=%d, fnum=%d, file_des=%d, fname=%s\n",
n, fnum, file_des, getFunctionName((enum detFuncs)fnum))); n, fnum, file_des, getFunctionName((enum detFuncs)fnum)));
return FAIL; return FAIL;
} else } else
FILE_LOG(logDEBUG5, ("Received %d bytes\n", n )); FILE_LOG(logDEBUG3, ("Received %d bytes\n", n ));
// jungfrau in programming mode // jungfrau in programming mode
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
@ -106,14 +106,15 @@ int decode_function(int file_des) {
FILE_LOG(logERROR, ("Unknown function enum %d\n", fnum)); FILE_LOG(logERROR, ("Unknown function enum %d\n", fnum));
ret=(M_nofunc)(file_des); ret=(M_nofunc)(file_des);
} else { } else {
FILE_LOG(logDEBUG5, (" calling function fnum=%d, (%s)\n", FILE_LOG(logDEBUG1, (" calling function fnum=%d, (%s)\n",
fnum, getFunctionName((enum detFuncs)fnum))); fnum, getFunctionName((enum detFuncs)fnum)));
ret = (*flist[fnum])(file_des); ret = (*flist[fnum])(file_des);
if (ret == FAIL) { if (ret == FAIL) {
FILE_LOG(logDEBUG5, ("Error executing the function = %d (%s)\n", FILE_LOG(logDEBUG1, ("Error executing the function = %d (%s)\n",
fnum, getFunctionName((enum detFuncs)fnum))); fnum, getFunctionName((enum detFuncs)fnum)));
} } else FILE_LOG(logDEBUG1, ("Function (%s) executed ok\n",
getFunctionName((enum detFuncs)fnum)));
} }
return ret; return ret;
} }
@ -252,7 +253,7 @@ void function_table() {
int iloop = 0; int iloop = 0;
for (iloop = 0; iloop < NUM_DET_FUNCTIONS ; ++iloop) { for (iloop = 0; iloop < NUM_DET_FUNCTIONS ; ++iloop) {
FILE_LOG(logDEBUG5, ("function fnum=%d, (%s) located at 0x%x\n", iloop, FILE_LOG(logDEBUG1, ("function fnum=%d, (%s) located at 0x%x\n", iloop,
getFunctionName((enum detFuncs)iloop), (unsigned int)flist[iloop])); getFunctionName((enum detFuncs)iloop), (unsigned int)flist[iloop]));
} }
} }
@ -373,7 +374,7 @@ int get_detector_type(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
enum detectorType retval = myDetectorType; enum detectorType retval = myDetectorType;
FILE_LOG(logDEBUG5,("Returning detector type %d\n", retval)); FILE_LOG(logDEBUG1,("Returning detector type %d\n", retval));
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -392,7 +393,7 @@ int set_external_signal_flag(int file_des) {
int signalindex = args[0]; int signalindex = args[0];
enum externalSignalFlag flag = args[1]; enum externalSignalFlag flag = args[1];
FILE_LOG(logDEBUG5, ("Setting external signal %d to flag %d\n", signalindex, flag)); FILE_LOG(logDEBUG1, ("Setting external signal %d to flag %d\n", signalindex, flag));
#ifndef GOTTHARDD #ifndef GOTTHARDD
functionNotImplemented(); functionNotImplemented();
@ -404,7 +405,7 @@ int set_external_signal_flag(int file_des) {
// get // get
retval = getExtSignal(signalindex); retval = getExtSignal(signalindex);
validate((int)flag, (int)retval, "set external signal flag", 1); validate((int)flag, (int)retval, "set external signal flag", 1);
FILE_LOG(logDEBUG5, ("External Signal Flag: %d\n", retval)); FILE_LOG(logDEBUG1, ("External Signal Flag: %d\n", retval));
} }
#endif #endif
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
@ -421,7 +422,7 @@ int set_external_communication_mode(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting external communication mode to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting external communication mode to %d\n", arg));
// set // set
if ((arg != GET_EXTERNAL_COMMUNICATION_MODE) && (Server_VerifyLock() == OK)) { if ((arg != GET_EXTERNAL_COMMUNICATION_MODE) && (Server_VerifyLock() == OK)) {
@ -442,7 +443,7 @@ int set_external_communication_mode(int file_des) {
// get // get
retval = getTiming(); retval = getTiming();
validate((int)arg, (int)retval, "set timing mode", 0); validate((int)arg, (int)retval, "set timing mode", 0);
FILE_LOG(logDEBUG5, ("Timing Mode: %d\n",retval)); FILE_LOG(logDEBUG1, ("Timing Mode: %d\n",retval));
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -457,7 +458,7 @@ int get_id(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Getting Id %d\n", arg)); FILE_LOG(logDEBUG1, ("Getting Id %d\n", arg));
// get // get
switch (arg) { switch (arg) {
@ -468,7 +469,7 @@ int get_id(int file_des) {
case DETECTOR_FIRMWARE_VERSION: case DETECTOR_FIRMWARE_VERSION:
case DETECTOR_SOFTWARE_VERSION: case DETECTOR_SOFTWARE_VERSION:
retval = getDetectorId(arg); retval = getDetectorId(arg);
FILE_LOG(logDEBUG5, ("Id(%d): %lld\n", retval)); FILE_LOG(logDEBUG1, ("Id(%d): %lld\n", retval));
break; break;
default: default:
modeNotImplemented("ID Index", (int)arg); modeNotImplemented("ID Index", (int)arg);
@ -492,9 +493,9 @@ int digital_test(int file_des) {
enum digitalTestMode mode = args[0]; enum digitalTestMode mode = args[0];
#ifdef GOTTHARDD #ifdef GOTTHARDD
int ival = args[1]; int ival = args[1];
FILE_LOG(logDEBUG5, ("Digital test, mode = %d, ival:%d\n", mode, ival)); FILE_LOG(logDEBUG1, ("Digital test, mode = %d, ival:%d\n", mode, ival));
#else #else
FILE_LOG(logDEBUG5, ("Digital test, mode = %d\n", mode)); FILE_LOG(logDEBUG1, ("Digital test, mode = %d\n", mode));
#endif #endif
#ifdef EIGERD #ifdef EIGERD
@ -505,7 +506,7 @@ int digital_test(int file_des) {
switch (mode) { switch (mode) {
#ifdef GOTTHARDD #ifdef GOTTHARDD
case DIGITAL_BIT_TEST: case DIGITAL_BIT_TEST:
FILE_LOG(logDEBUG5, ("Setting digital test bit: %d\n", ival)); FILE_LOG(logDEBUG1, ("Setting digital test bit: %d\n", ival));
if (ival >= 0) if (ival >= 0)
digitalTestBit = (ival > 0) ? 1 : 0; digitalTestBit = (ival > 0) ? 1 : 0;
retval = digitalTestBit; retval = digitalTestBit;
@ -514,7 +515,7 @@ int digital_test(int file_des) {
case DETECTOR_FIRMWARE_TEST: case DETECTOR_FIRMWARE_TEST:
case DETECTOR_BUS_TEST: case DETECTOR_BUS_TEST:
retval = detectorTest(mode); retval = detectorTest(mode);
FILE_LOG(logDEBUG5, ("Digital Test (%d): %d\n", mode, retval)); FILE_LOG(logDEBUG1, ("Digital Test (%d): %d\n", mode, retval));
break; break;
default: default:
modeNotImplemented("Digital Test Mode", (int)mode); modeNotImplemented("Digital Test Mode", (int)mode);
@ -630,7 +631,7 @@ int set_dac(int file_des) {
// index exists // index exists
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5, ("Setting DAC %d to %d %s\n", serverDacIndex, val, FILE_LOG(logDEBUG1, ("Setting DAC %d to %d %s\n", serverDacIndex, val,
(mV ? "mV" : "dac units"))); (mV ? "mV" : "dac units")));
// set & get // set & get
@ -641,7 +642,7 @@ int set_dac(int file_des) {
#ifdef EIGERD #ifdef EIGERD
case IO_DELAY: case IO_DELAY:
retval[0] = setIODelay(val); retval[0] = setIODelay(val);
FILE_LOG(logDEBUG5, ("IODelay: %d\n", retval[0])); FILE_LOG(logDEBUG1, ("IODelay: %d\n", retval[0]));
break; break;
#endif #endif
@ -649,7 +650,7 @@ int set_dac(int file_des) {
case HV_POT: case HV_POT:
case HV_NEW: case HV_NEW:
retval[0] = setHighVoltage(val); retval[0] = setHighVoltage(val);
FILE_LOG(logDEBUG5, ("High Voltage: %d\n", retval[0])); FILE_LOG(logDEBUG1, ("High Voltage: %d\n", retval[0]));
#ifdef EIGERD #ifdef EIGERD
if ((retval[0] != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval[0] < 0)) { if ((retval[0] != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval[0] < 0)) {
ret = FAIL; ret = FAIL;
@ -704,7 +705,7 @@ int set_dac(int file_des) {
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
} }
FILE_LOG(logDEBUG5, ("Dac (%d): %d dac units and %d mV\n", serverDacIndex, retval[0], retval[1])); FILE_LOG(logDEBUG1, ("Dac (%d): %d dac units and %d mV\n", serverDacIndex, retval[0], retval[1]));
break; break;
} }
} }
@ -769,9 +770,9 @@ int get_adc(int file_des) {
// valid index // valid index
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5, ("Getting ADC %d\n", serverAdcIndex)); FILE_LOG(logDEBUG1, ("Getting ADC %d\n", serverAdcIndex));
retval = getADC(serverAdcIndex); retval = getADC(serverAdcIndex);
FILE_LOG(logDEBUG5, ("ADC(%d): %d\n", retval)); FILE_LOG(logDEBUG1, ("ADC(%d): %d\n", retval));
} }
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -790,7 +791,7 @@ int write_register(int file_des) {
return printSocketReadError(); return printSocketReadError();
uint32_t addr = args[0]; uint32_t addr = args[0];
uint32_t val = args[1]; uint32_t val = args[1];
FILE_LOG(logDEBUG5, ("Writing to register 0x%x, data 0x%x\n", addr, val)); FILE_LOG(logDEBUG1, ("Writing to register 0x%x, data 0x%x\n", addr, val));
// only set // only set
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
@ -801,7 +802,7 @@ int write_register(int file_des) {
sprintf(mess,"Could not write to register 0x%x. Wrote 0x%x but read 0x%x\n", addr, val, retval); sprintf(mess,"Could not write to register 0x%x. Wrote 0x%x but read 0x%x\n", addr, val, retval);
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("Write register (0x%x): 0x%x\n", retval)); FILE_LOG(logDEBUG1, ("Write register (0x%x): 0x%x\n", retval));
} }
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -819,11 +820,11 @@ int read_register(int file_des) {
if (receiveData(file_des, &addr, sizeof(addr), INT32) < 0) if (receiveData(file_des, &addr, sizeof(addr), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Reading from register 0x%x\n", addr)); FILE_LOG(logDEBUG1, ("Reading from register 0x%x\n", addr));
// get // get
retval = readRegister(addr); retval = readRegister(addr);
FILE_LOG(logDEBUG5, ("Read register (0x%x): 0x%x\n", retval)); FILE_LOG(logDEBUG1, ("Read register (0x%x): 0x%x\n", retval));
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -892,7 +893,7 @@ int set_module(int file_des) {
if (myAdc != NULL) free(myAdc); if (myAdc != NULL) free(myAdc);
return printSocketReadError(); return printSocketReadError();
} }
FILE_LOG(logDEBUG5, ("module register is %d, nchan %d, nchip %d, " FILE_LOG(logDEBUG1, ("module register is %d, nchan %d, nchip %d, "
"ndac %d, nadc %d, iodelay %d, tau %d, eV %d\n", "ndac %d, nadc %d, iodelay %d, tau %d, eV %d\n",
module.reg, module.nchan, module.nchip, module.reg, module.nchan, module.nchip,
module.ndac, module.nadc, module.iodelay, module.tau, module.eV)); module.ndac, module.nadc, module.iodelay, module.tau, module.eV));
@ -944,7 +945,7 @@ int set_module(int file_des) {
ret = setModule(module, mess); ret = setModule(module, mess);
retval = getSettings(); retval = getSettings();
validate(module.reg, (int)retval, "set module (settings)", 0); validate(module.reg, (int)retval, "set module (settings)", 0);
FILE_LOG(logDEBUG5, ("Settings: %d\n", retval)); FILE_LOG(logDEBUG1, ("Settings: %d\n", retval));
} }
if (myChan != NULL) free(myChan); if (myChan != NULL) free(myChan);
if (myDac != NULL) free(myDac); if (myDac != NULL) free(myDac);
@ -1010,9 +1011,9 @@ int get_module(int file_des) {
module.nadc = getNumberOfADCs(); module.nadc = getNumberOfADCs();
// only get // only get
FILE_LOG(logDEBUG5, ("Getting module\n")); FILE_LOG(logDEBUG1, ("Getting module\n"));
getModule(&module); getModule(&module);
FILE_LOG(logDEBUG5, ("Getting module. Settings:%d\n", module.reg)); FILE_LOG(logDEBUG1, ("Getting module. Settings:%d\n", module.reg));
} }
Server_SendResult(file_des, INT32, 1, NULL, 0); Server_SendResult(file_des, INT32, 1, NULL, 0);
@ -1040,7 +1041,7 @@ int set_settings(int file_des) {
if (receiveData(file_des, &isett, sizeof(isett), INT32) < 0) if (receiveData(file_des, &isett, sizeof(isett), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting settings %d\n", isett)); FILE_LOG(logDEBUG1, ("Setting settings %d\n", isett));
//set & get //set & get
if ((isett == GET_SETTINGS) || ((isett != GET_SETTINGS) && (Server_VerifyLock() == OK))) { if ((isett == GET_SETTINGS) || ((isett != GET_SETTINGS) && (Server_VerifyLock() == OK))) {
@ -1076,7 +1077,7 @@ int set_settings(int file_des) {
// if index is okay, set & get // if index is okay, set & get
if (ret == OK) { if (ret == OK) {
retval = setSettings(isett); retval = setSettings(isett);
FILE_LOG(logDEBUG5, ("Settings: %d\n", retval)); FILE_LOG(logDEBUG1, ("Settings: %d\n", retval));
validate((int)isett, (int)retval, "set settings", 0); validate((int)isett, (int)retval, "set settings", 0);
#if defined(JUNGFRAUD) || defined (GOTTHARDD) #if defined(JUNGFRAUD) || defined (GOTTHARDD)
if (ret == OK && isett >= 0) { if (ret == OK && isett >= 0) {
@ -1101,13 +1102,13 @@ int get_threshold_energy(int file_des) {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
int retval = -1; int retval = -1;
FILE_LOG(logDEBUG5, ("Getting Threshold energy\n")); FILE_LOG(logDEBUG1, ("Getting Threshold energy\n"));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
#else #else
// only get // only get
retval = getThresholdEnergy(); retval = getThresholdEnergy();
FILE_LOG(logDEBUG5, ("Threshold energy: %d eV\n", retval)); FILE_LOG(logDEBUG1, ("Threshold energy: %d eV\n", retval));
#endif #endif
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -1121,7 +1122,7 @@ int start_acquisition(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Starting Acquisition\n")); FILE_LOG(logDEBUG1, ("Starting Acquisition\n"));
// only set // only set
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
ret = startStateMachine(); ret = startStateMachine();
@ -1129,7 +1130,7 @@ int start_acquisition(int file_des) {
sprintf(mess, "Could not start acquisition\n"); sprintf(mess, "Could not start acquisition\n");
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("Starting Acquisition ret: %d\n", ret)); FILE_LOG(logDEBUG1, ("Starting Acquisition ret: %d\n", ret));
} }
return Server_SendResult(file_des, INT32, 1, NULL, 0); return Server_SendResult(file_des, INT32, 1, NULL, 0);
} }
@ -1140,7 +1141,7 @@ int stop_acquisition(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Stopping Acquisition\n")); FILE_LOG(logDEBUG1, ("Stopping Acquisition\n"));
// only set // only set
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
ret = stopStateMachine(); ret = stopStateMachine();
@ -1148,7 +1149,7 @@ int stop_acquisition(int file_des) {
sprintf(mess, "Could not stop acquisition\n"); sprintf(mess, "Could not stop acquisition\n");
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("Stopping Acquisition ret: %d\n", ret)); FILE_LOG(logDEBUG1, ("Stopping Acquisition ret: %d\n", ret));
} }
return Server_SendResult(file_des, INT32, 1, NULL, 0); return Server_SendResult(file_des, INT32, 1, NULL, 0);
} }
@ -1161,7 +1162,7 @@ int start_readout(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Starting readout\n")); FILE_LOG(logDEBUG1, ("Starting readout\n"));
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
#else #else
@ -1172,7 +1173,7 @@ int start_readout(int file_des) {
sprintf(mess, "Could not start readout\n"); sprintf(mess, "Could not start readout\n");
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("Starting readout ret: %d\n", ret)); FILE_LOG(logDEBUG1, ("Starting readout ret: %d\n", ret));
} }
#endif #endif
return Server_SendResult(file_des, INT32, 1, NULL, 0); return Server_SendResult(file_des, INT32, 1, NULL, 0);
@ -1188,10 +1189,10 @@ int get_run_status(int file_des) {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
enum runStatus retval = ERROR; enum runStatus retval = ERROR;
FILE_LOG(logDEBUG5, ("Getting status\n")); FILE_LOG(logDEBUG1, ("Getting status\n"));
// only get // only get
retval = getRunStatus(); retval = getRunStatus();
FILE_LOG(logDEBUG5, ("Status: %d\n", retval)); FILE_LOG(logDEBUG1, ("Status: %d\n", retval));
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
} }
@ -1203,9 +1204,9 @@ int start_and_read_all(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Starting Acquisition and read all frames\n")); FILE_LOG(logDEBUG1, ("Starting Acquisition and read all frames\n"));
// start state machine // start state machine
FILE_LOG(logDEBUG5, ("Stopping Acquisition\n")); FILE_LOG(logDEBUG1, ("Stopping Acquisition\n"));
// only set // only set
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
ret = startStateMachine(); ret = startStateMachine();
@ -1213,7 +1214,7 @@ int start_and_read_all(int file_des) {
sprintf(mess, "Could not start acquisition\n"); sprintf(mess, "Could not start acquisition\n");
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("Starting Acquisition ret: %d\n", ret)); FILE_LOG(logDEBUG1, ("Starting Acquisition ret: %d\n", ret));
} }
@ -1232,7 +1233,7 @@ int read_all(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Reading all frames\n")); FILE_LOG(logDEBUG1, ("Reading all frames\n"));
// only set // only set
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
readFrame(&ret, mess); readFrame(&ret, mess);
@ -1258,7 +1259,7 @@ int set_timer(int file_des) {
#ifdef EIGERD #ifdef EIGERD
int64_t subexptime = 0; int64_t subexptime = 0;
#endif #endif
FILE_LOG(logDEBUG5, ("Setting timer index %d to %lld ns\n", ind, tns)); FILE_LOG(logDEBUG1, ("Setting timer index %d to %lld ns\n", ind, tns));
// set & get // set & get
if ((tns == -1) || ((tns != -1) && (Server_VerifyLock() == OK))) { if ((tns == -1) || ((tns != -1) && (Server_VerifyLock() == OK))) {
@ -1318,7 +1319,7 @@ int set_timer(int file_des) {
validate64(tns, retval, "set timer", 0); validate64(tns, retval, "set timer", 0);
} }
if (ret != FAIL) { if (ret != FAIL) {
FILE_LOG(logDEBUG5, ("Timer index %d: %lld\n", ind, retval)); FILE_LOG(logDEBUG1, ("Timer index %d: %lld\n", ind, retval));
} }
return Server_SendResult(file_des, INT64, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT64, 1, &retval, sizeof(retval));
} }
@ -1337,7 +1338,7 @@ int get_time_left(int file_des) {
if (receiveData(file_des, &ind, sizeof(ind), INT32) < 0) if (receiveData(file_des, &ind, sizeof(ind), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Getting timer left index %d\n", ind)); FILE_LOG(logDEBUG1, ("Getting timer left index %d\n", ind));
// only get // only get
// check index // check index
@ -1362,7 +1363,7 @@ int get_time_left(int file_des) {
case MEASUREMENT_TIME: case MEASUREMENT_TIME:
#endif #endif
retval = getTimeLeft(ind); retval = getTimeLeft(ind);
FILE_LOG(logDEBUG5, ("Timer left index %d: %lld\n", ind, retval)); FILE_LOG(logDEBUG1, ("Timer left index %d: %lld\n", ind, retval));
break; break;
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
case DELAY_AFTER_TRIGGER: case DELAY_AFTER_TRIGGER:
@ -1392,7 +1393,7 @@ int set_dynamic_range(int file_des) {
if (receiveData(file_des, &dr, sizeof(dr), INT32) < 0) if (receiveData(file_des, &dr, sizeof(dr), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting dr to %d\n", dr)); FILE_LOG(logDEBUG1, ("Setting dr to %d\n", dr));
// set & get // set & get
if ((dr == -1) || ((dr != -1) && (Server_VerifyLock() == OK))) { if ((dr == -1) || ((dr != -1) && (Server_VerifyLock() == OK))) {
@ -1408,7 +1409,7 @@ int set_dynamic_range(int file_des) {
case 4: case 8: case 32: case 4: case 8: case 32:
#endif #endif
retval = setDynamicRange(dr); retval = setDynamicRange(dr);
FILE_LOG(logDEBUG5, ("Dynamic range: %d\n", retval)); FILE_LOG(logDEBUG1, ("Dynamic range: %d\n", retval));
validate(dr, retval, "set dynamic range", 0); validate(dr, retval, "set dynamic range", 0);
if (dr >= 0) if (dr >= 0)
dataBytes=calculateDataBytes(); dataBytes=calculateDataBytes();
@ -1457,7 +1458,7 @@ int set_readout_flags(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting readout flags to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting readout flags to %d\n", arg));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -1474,8 +1475,8 @@ int set_readout_flags(int file_des) {
case SHOW_OVERFLOW: case SHOW_OVERFLOW:
case NOOVERFLOW: case NOOVERFLOW:
retval = setReadOutFlags(arg); retval = setReadOutFlags(arg);
FILE_LOG(logDEBUG5, ("Read out flags: %d\n", retval)); FILE_LOG(logDEBUG1, ("Read out flags: 0x%x\n", retval));
validate((int)arg, (int)retval, "set readout flag", 0); validate((int)arg, (int)(retval & arg), "set readout flag", 1);
break; break;
default: default:
modeNotImplemented("Read out flag index", (int)arg); modeNotImplemented("Read out flag index", (int)arg);
@ -1516,11 +1517,11 @@ int set_roi(int file_des) {
return printSocketReadError(); return printSocketReadError();
} }
} }
FILE_LOG(logDEBUG5, ("Set ROI (narg:%d)\n", narg)); FILE_LOG(logDEBUG1, ("Set ROI (narg:%d)\n", narg));
{ {
int iloop = 0; int iloop = 0;
for (iloop = 0; iloop < narg; ++iloop) { for (iloop = 0; iloop < narg; ++iloop) {
FILE_LOG(logDEBUG5, ("%d: %d\t%d\t%d\t%d\n", FILE_LOG(logDEBUG1, ("%d: %d\t%d\t%d\t%d\n",
arg[iloop].xmin, arg[iloop].xmax, arg[iloop].ymin, arg[iloop].ymax)); arg[iloop].xmin, arg[iloop].xmax, arg[iloop].ymin, arg[iloop].ymax));
} }
} }
@ -1536,7 +1537,7 @@ int set_roi(int file_des) {
"Set %d rois, but read %d rois\n", narg, nretval); "Set %d rois, but read %d rois\n", narg, nretval);
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("nRois: %d\n", nretval)); FILE_LOG(logDEBUG1, ("nRois: %d\n", nretval));
} }
#endif #endif
@ -1571,7 +1572,7 @@ int set_speed(int file_des) {
return printSocketReadError(); return printSocketReadError();
enum speedVariable ind = args[0]; enum speedVariable ind = args[0];
int val = args[1]; int val = args[1];
FILE_LOG(logDEBUG5, ("Setting speed index %d to %d\n", ind, val)); FILE_LOG(logDEBUG1, ("Setting speed index %d to %d\n", ind, val));
// set & get // set & get
if ((val == -1) || ((val != -1) && (Server_VerifyLock() == OK))) { if ((val == -1) || ((val != -1) && (Server_VerifyLock() == OK))) {
@ -1580,7 +1581,7 @@ int set_speed(int file_des) {
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
case ADC_PHASE: case ADC_PHASE:
retval = adcPhase(val); retval = adcPhase(val);
FILE_LOG(logDEBUG5, ("ADc Phase: %d\n", retval)); FILE_LOG(logDEBUG1, ("ADc Phase: %d\n", retval));
if (val != 100000) { if (val != 100000) {
validate(val, retval, "set adc phase ", 0); validate(val, retval, "set adc phase ", 0);
} }
@ -1588,7 +1589,7 @@ int set_speed(int file_des) {
#endif #endif
case CLOCK_DIVIDER: case CLOCK_DIVIDER:
retval = setSpeed(val); retval = setSpeed(val);
FILE_LOG(logDEBUG5, ("Clock: %d\n", retval)); FILE_LOG(logDEBUG1, ("Clock: %d\n", retval));
validate(val, retval, "set clock ", 0); validate(val, retval, "set clock ", 0);
break; break;
default: default:
@ -1622,7 +1623,7 @@ int lock_server(int file_des) {
if (receiveData(file_des, &lock, sizeof(lock), INT32) < 0) if (receiveData(file_des, &lock, sizeof(lock), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Locking Server to %d\n", lock)); FILE_LOG(logDEBUG1, ("Locking Server to %d\n", lock));
// set // set
if (lock >= 0) { if (lock >= 0) {
@ -1787,13 +1788,13 @@ int configure_mac(int file_des) {
if (receiveData(file_des, args, sizeof(args), OTHER) < 0) if (receiveData(file_des, args, sizeof(args), OTHER) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("\n Configuring UDP Destination\n")); FILE_LOG(logDEBUG1, ("\n Configuring UDP Destination\n"));
#ifdef GOTTHARDD #ifdef GOTTHARDD
FILE_LOG(logDEBUG5, ("Digital Test Bit %d\t", digitalTestBit); FILE_LOG(logDEBUG1, ("Digital Test Bit %d\t", digitalTestBit);
#endif #endif
uint32_t dstIp = 0; uint32_t dstIp = 0;
sscanf(args[0], "%x", &dstIp); sscanf(args[0], "%x", &dstIp);
FILE_LOG(logDEBUG5, ("Dst Ip Addr: %d.%d.%d.%d = 0x%x \n", FILE_LOG(logDEBUG1, ("Dst Ip Addr: %d.%d.%d.%d = 0x%x \n",
(dstIp >> 24) & 0xff, (dstIp >> 16) & 0xff, (dstIp >> 8) & 0xff, (dstIp) & 0xff, (dstIp >> 24) & 0xff, (dstIp >> 16) & 0xff, (dstIp >> 8) & 0xff, (dstIp) & 0xff,
dstIp)); dstIp));
uint64_t dstMac = 0; uint64_t dstMac = 0;
@ -1802,43 +1803,43 @@ int configure_mac(int file_des) {
#else #else
sscanf(args[1], "%llx", &dstMac); sscanf(args[1], "%llx", &dstMac);
#endif #endif
FILE_LOG(logDEBUG5, ("Dst Mac Addr: (0x) ")); FILE_LOG(logDEBUG1, ("Dst Mac Addr: (0x) "));
{ {
int iloop = 5; int iloop = 5;
for (iloop = 5; iloop >= 0; --iloop) { for (iloop = 5; iloop >= 0; --iloop) {
FILE_LOG(logDEBUG5, ("%x", (unsigned int)(((dstMac >> (8 * iloop)) & 0xFF)))); FILE_LOG(logDEBUG1, ("%x", (unsigned int)(((dstMac >> (8 * iloop)) & 0xFF))));
if (iloop > 0) { if (iloop > 0) {
FILE_LOG(logDEBUG5, (":")); FILE_LOG(logDEBUG1, (":"));
} }
} }
} }
FILE_LOG(logDEBUG5, (" = %llx\n", dstMac)); FILE_LOG(logDEBUG1, (" = %llx\n", dstMac));
uint32_t dstPort = 0; uint32_t dstPort = 0;
sscanf(args[2], "%x", &dstPort); sscanf(args[2], "%x", &dstPort);
FILE_LOG(logDEBUG5, ("Dst Port: %x\n", dstPort)); FILE_LOG(logDEBUG1, ("Dst Port: %x\n", dstPort));
uint32_t dstPort2 = 0; uint32_t dstPort2 = 0;
sscanf(args[5], "%x", &dstPort2); sscanf(args[5], "%x", &dstPort2);
FILE_LOG(logDEBUG5, ("Dst Port2: %x\n", dstPort2)); FILE_LOG(logDEBUG1, ("Dst Port2: %x\n", dstPort2));
uint64_t srcMac = 0; uint64_t srcMac = 0;
#ifdef VIRTUAL #ifdef VIRTUAL
sscanf(args[3], "%lx", &srcMac); sscanf(args[3], "%lx", &srcMac);
#else #else
sscanf(args[3], "%llx", &srcMac); sscanf(args[3], "%llx", &srcMac);
#endif #endif
FILE_LOG(logDEBUG5, ("Src Mac Addr: (0x) ")); FILE_LOG(logDEBUG1, ("Src Mac Addr: (0x) "));
{ {
int iloop = 5; int iloop = 5;
for (iloop = 5; iloop >= 0; --iloop) { for (iloop = 5; iloop >= 0; --iloop) {
FILE_LOG(logDEBUG5, ("%x", (unsigned int)(((srcMac >> (8 * iloop)) & 0xFF)))); FILE_LOG(logDEBUG1, ("%x", (unsigned int)(((srcMac >> (8 * iloop)) & 0xFF))));
if (iloop > 0) { if (iloop > 0) {
FILE_LOG(logDEBUG5, (":")); FILE_LOG(logDEBUG1, (":"));
} }
} }
} }
FILE_LOG(logDEBUG5, (" = %llx\n", srcMac)); FILE_LOG(logDEBUG1, (" = %llx\n", srcMac));
uint32_t srcIp = 0; uint32_t srcIp = 0;
sscanf(args[4], "%x", &srcIp); sscanf(args[4], "%x", &srcIp);
FILE_LOG(logDEBUG5, ("Src Ip Addr: %d.%d.%d.%d = 0x%x \n", FILE_LOG(logDEBUG1, ("Src Ip Addr: %d.%d.%d.%d = 0x%x \n",
(srcIp >> 24) & 0xff, (srcIp >> 16) & 0xff, (srcIp >> 8) & 0xff, (srcIp) & 0xff, (srcIp >> 24) & 0xff, (srcIp >> 16) & 0xff, (srcIp >> 8) & 0xff, (srcIp) & 0xff,
srcIp)); srcIp));
#if defined(JUNGFRAUD) || defined(EIGERD) #if defined(JUNGFRAUD) || defined(EIGERD)
@ -1846,7 +1847,7 @@ int configure_mac(int file_des) {
sscanf(args[6], "%x", &pos[0]); sscanf(args[6], "%x", &pos[0]);
sscanf(args[7], "%x", &pos[1]); sscanf(args[7], "%x", &pos[1]);
sscanf(args[8], "%x", &pos[2]); sscanf(args[8], "%x", &pos[2]);
FILE_LOG(logDEBUG5, ("Position: [%d, %d, %d]\n", pos[0], pos[1], pos[2])); FILE_LOG(logDEBUG1, ("Position: [%d, %d, %d]\n", pos[0], pos[1], pos[2]));
#endif #endif
// set only // set only
@ -1863,12 +1864,12 @@ int configure_mac(int file_des) {
#ifdef EIGERD #ifdef EIGERD
// change mac to hardware mac // change mac to hardware mac
if (srcMac != getDetectorMAC()) { if (srcMac != getDetectorMAC()) {
FILE_LOG(logERROR, ("actual detector mac address %llx does not match " FILE_LOG(logWARNING, ("actual detector mac address %llx does not match "
"the one from client %llx\n", "the one from client %llx\n",
(long long unsigned int)getDetectorMAC(), (long long unsigned int)getDetectorMAC(),
(long long unsigned int)srcMac)); (long long unsigned int)srcMac));
srcMac = getDetectorMAC(); srcMac = getDetectorMAC();
FILE_LOG(logERROR,("matched detectormac to the hardware mac now\n")); FILE_LOG(logWARNING,("matched detectormac to the hardware mac now\n"));
} }
// always remember the ip sent from the client (could be for 10g(if not dhcp)) // always remember the ip sent from the client (could be for 10g(if not dhcp))
@ -1877,7 +1878,7 @@ int configure_mac(int file_des) {
//only for 1Gbe, change ip to hardware ip //only for 1Gbe, change ip to hardware ip
if (!enableTenGigabitEthernet(-1)) { if (!enableTenGigabitEthernet(-1)) {
FILE_LOG(logERROR, ("using DHCP IP for Configuring MAC\n")); FILE_LOG(logWARNING, ("Using DHCP IP for Configuring MAC\n"));
srcIp = getDetectorIP(); srcIp = getDetectorIP();
} }
// 10 gbe (use ip given from client) // 10 gbe (use ip given from client)
@ -1887,11 +1888,11 @@ int configure_mac(int file_des) {
#endif #endif
#ifdef GOTTHARDD #ifdef GOTTHARDD
iretval = configureMAC(dstIp, dstMac, srcMac, srcIp, dstPort, dstPort2, digitalTestBit); iretval = configureMAC(dstIp, dstMac, srcMac, srcIp, dstPort, dstPort2, digitalTestBit);
FILE_LOG(logDEBUG5, ("Configure mac retval: %d\n", iretval)); FILE_LOG(logDEBUG1, ("Configure mac retval: %d\n", iretval));
FILE_LOG(logINFO, ("Configure MAC successful: %d\n", iretval)); FILE_LOG(logINFO, ("Configure MAC successful: %d\n", iretval));
#else #else
iretval = configureMAC(dstIp, dstMac, srcMac, srcIp, dstPort, dstPort2); iretval = configureMAC(dstIp, dstMac, srcMac, srcIp, dstPort, dstPort2);
FILE_LOG(logDEBUG5, ("Configure mac retval: %d\n", iretval)); FILE_LOG(logDEBUG1, ("Configure mac retval: %d\n", iretval));
if (iretval == -1) { if (iretval == -1) {
ret = FAIL; ret = FAIL;
@ -1938,7 +1939,7 @@ int load_image(int file_des) {
return printSocketReadError(); return printSocketReadError();
} }
} }
FILE_LOG(logDEBUG5, ("Loading %s image (ind:%d)\n", (index == DARK_IMAGE) ? "dark" : FILE_LOG(logDEBUG1, ("Loading %s image (ind:%d)\n", (index == DARK_IMAGE) ? "dark" :
((index == GAIN_IMAGE) ? "gain" : "unknown"), index)); ((index == GAIN_IMAGE) ? "gain" : "unknown"), index));
#ifndef GOTTHARDD #ifndef GOTTHARDD
@ -1951,7 +1952,7 @@ int load_image(int file_des) {
case DARK_IMAGE : case DARK_IMAGE :
case GAIN_IMAGE : case GAIN_IMAGE :
ret = loadImage(index, ImageVals); ret = loadImage(index, ImageVals);
FILE_LOG(logDEBUG5, ("Loading image ret: %d\n", ret)); FILE_LOG(logDEBUG1, ("Loading image ret: %d\n", ret));
if (ret == FAIL) { if (ret == FAIL) {
sprintf(mess, "Could not load image\n"); sprintf(mess, "Could not load image\n");
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
@ -1980,7 +1981,7 @@ int read_counter_block(int file_des) {
if (receiveData(file_des, &startACQ, sizeof(startACQ), INT32) < 0) if (receiveData(file_des, &startACQ, sizeof(startACQ), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Read counter block with start acq bit: %d\n", startACQ)); FILE_LOG(logDEBUG1, ("Read counter block with start acq bit: %d\n", startACQ));
#ifndef GOTTHARDD #ifndef GOTTHARDD
functionNotImplemented(); functionNotImplemented();
@ -2009,7 +2010,7 @@ int reset_counter_block(int file_des) {
if (receiveData(file_des, &startACQ, sizeof(startACQ), INT32) < 0) if (receiveData(file_des, &startACQ, sizeof(startACQ), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Reset counter block with start acq bit: %d\n", startACQ)); FILE_LOG(logDEBUG1, ("Reset counter block with start acq bit: %d\n", startACQ));
#ifndef GOTTHARDD #ifndef GOTTHARDD
functionNotImplemented(); functionNotImplemented();
@ -2039,7 +2040,7 @@ int enable_ten_giga(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Enable/ Disable 10GbE : %d\n", arg)); FILE_LOG(logDEBUG1, ("Enable/ Disable 10GbE : %d\n", arg));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2047,7 +2048,7 @@ int enable_ten_giga(int file_des) {
// set & get // set & get
if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) { if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) {
retval = enableTenGigabitEthernet(arg); retval = enableTenGigabitEthernet(arg);
FILE_LOG(logDEBUG5, ("10GbE: %d\n", retval)); FILE_LOG(logDEBUG1, ("10GbE: %d\n", retval));
validate(arg, retval, "enable/disable 10GbE", 0); validate(arg, retval, "enable/disable 10GbE", 0);
} }
#endif #endif
@ -2065,7 +2066,7 @@ int set_all_trimbits(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Set all trmbits to %d\n", arg)); FILE_LOG(logDEBUG1, ("Set all trmbits to %d\n", arg));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2080,7 +2081,7 @@ int set_all_trimbits(int file_des) {
} }
// get // get
retval = getAllTrimbits(); retval = getAllTrimbits();
FILE_LOG(logDEBUG5, ("All trimbits: %d\n", retval)); FILE_LOG(logDEBUG1, ("All trimbits: %d\n", retval));
validate(arg, retval, "set all trimbits", 0); validate(arg, retval, "set all trimbits", 0);
#endif #endif
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
@ -2108,7 +2109,7 @@ int write_adc_register(int file_des) {
return printSocketReadError(); return printSocketReadError();
uint32_t addr = args[0]; uint32_t addr = args[0];
uint32_t val = args[1]; uint32_t val = args[1];
FILE_LOG(logDEBUG5, ("Writing 0x%x to ADC Register 0x%x\n", val, addr)); FILE_LOG(logDEBUG1, ("Writing 0x%x to ADC Register 0x%x\n", val, addr));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2131,7 +2132,7 @@ int set_counter_bit(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Set counter bit with value: %d\n", arg)); FILE_LOG(logDEBUG1, ("Set counter bit with value: %d\n", arg));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2143,7 +2144,7 @@ int set_counter_bit(int file_des) {
} }
// get // get
retval = setCounterBit(-1); retval = setCounterBit(-1);
FILE_LOG(logDEBUG5, ("Set counter bit retval: %d\n", retval)); FILE_LOG(logDEBUG1, ("Set counter bit retval: %d\n", retval));
validate(arg, retval, "set counter bit", 0); validate(arg, retval, "set counter bit", 0);
#endif #endif
return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, 1, &retval, sizeof(retval));
@ -2160,7 +2161,7 @@ int pulse_pixel(int file_des) {
if (receiveData(file_des, args, sizeof(args), INT32) < 0) if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Pulse pixel, n: %d, x: %d, y: %d\n", args[0], args[1], args[2])); FILE_LOG(logDEBUG1, ("Pulse pixel, n: %d, x: %d, y: %d\n", args[0], args[1], args[2]));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2187,7 +2188,7 @@ int pulse_pixel_and_move(int file_des) {
if (receiveData(file_des, args, sizeof(args), INT32) < 0) if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Pulse pixel and move, n: %d, x: %d, y: %d\n", FILE_LOG(logDEBUG1, ("Pulse pixel and move, n: %d, x: %d, y: %d\n",
args[0], args[1], args[2])); args[0], args[1], args[2]));
#ifndef EIGERD #ifndef EIGERD
@ -2217,7 +2218,7 @@ int pulse_chip(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Pulse chip: %d\n", arg)); FILE_LOG(logDEBUG1, ("Pulse chip: %d\n", arg));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2245,7 +2246,7 @@ int set_rate_correct(int file_des) {
if (receiveData(file_des, &tau_ns, sizeof(tau_ns), INT64) < 0) if (receiveData(file_des, &tau_ns, sizeof(tau_ns), INT64) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Set rate correct with tau %lld\n", (long long int)tau_ns)); FILE_LOG(logDEBUG1, ("Set rate correct with tau %lld\n", (long long int)tau_ns));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2288,12 +2289,12 @@ int get_rate_correct(int file_des) {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
int64_t retval = -1; int64_t retval = -1;
FILE_LOG(logDEBUG5, ("Getting rate correction\n")); FILE_LOG(logDEBUG1, ("Getting rate correction\n"));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
#else #else
retval = getCurrentTau(); retval = getCurrentTau();
FILE_LOG(logDEBUG5, ("Tau: %lld\n", (long long int)retval)); FILE_LOG(logDEBUG1, ("Tau: %lld\n", (long long int)retval));
#endif #endif
return Server_SendResult(file_des, INT64, 1, &retval, sizeof(retval)); return Server_SendResult(file_des, INT64, 1, &retval, sizeof(retval));
} }
@ -2313,7 +2314,7 @@ int set_network_parameter(int file_des) {
enum networkParameter mode = args[0]; enum networkParameter mode = args[0];
int value = args[1]; int value = args[1];
enum NETWORKINDEX serverIndex = 0; enum NETWORKINDEX serverIndex = 0;
FILE_LOG(logDEBUG5, ("Set network parameter index %d to %d\n", mode, value)); FILE_LOG(logDEBUG1, ("Set network parameter index %d to %d\n", mode, value));
#ifdef GOTTHARDD #ifdef GOTTHARDD
functionNotImplemented(); functionNotImplemented();
@ -2351,7 +2352,7 @@ int set_network_parameter(int file_des) {
// valid index // valid index
if (ret == OK) { if (ret == OK) {
retval = setNetworkParameter(serverIndex, value); retval = setNetworkParameter(serverIndex, value);
FILE_LOG(logDEBUG5, ("Network Parameter index %d: %d\n", serverIndex, retval)); FILE_LOG(logDEBUG1, ("Network Parameter index %d: %d\n", serverIndex, retval));
validate(value, retval, "set network parameter", 0); validate(value, retval, "set network parameter", 0);
} }
} }
@ -2368,7 +2369,7 @@ int program_fpga(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Programming FPGA\n")); FILE_LOG(logDEBUG1, ("Programming FPGA\n"));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
//to receive any arguments //to receive any arguments
int n = 1; int n = 1;
@ -2404,7 +2405,7 @@ int program_fpga(int file_des) {
if (receiveData(file_des,&filesize,sizeof(filesize),INT32) < 0) if (receiveData(file_des,&filesize,sizeof(filesize),INT32) < 0)
return printSocketReadError(); return printSocketReadError();
totalsize = filesize; totalsize = filesize;
FILE_LOG(logDEBUG5, ("Total program size is: %d\n", totalsize); FILE_LOG(logDEBUG1, ("Total program size is: %d\n", totalsize);
// opening file pointer to flash and telling FPGA to not touch flash // opening file pointer to flash and telling FPGA to not touch flash
if (startWritingFPGAprogram(&fp) != OK) { if (startWritingFPGAprogram(&fp) != OK) {
@ -2428,7 +2429,7 @@ int program_fpga(int file_des) {
unitprogramsize = MAX_FPGAPROGRAMSIZE; //2mb unitprogramsize = MAX_FPGAPROGRAMSIZE; //2mb
if (unitprogramsize > filesize) //less than 2mb if (unitprogramsize > filesize) //less than 2mb
unitprogramsize = filesize; unitprogramsize = filesize;
FILE_LOG(logDEBUG5, ("unit size to receive is:%d\n" FILE_LOG(logDEBUG1, ("unit size to receive is:%d\n"
"filesize:%d currentpointer:%d\n", "filesize:%d currentpointer:%d\n",
unitprogramsize, filesize, currentPointer)); unitprogramsize, filesize, currentPointer));
@ -2473,7 +2474,7 @@ int program_fpga(int file_des) {
if (fp != NULL) if (fp != NULL)
fclose(fp); fclose(fp);
FILE_LOG(logDEBUG5, ("Done with program receiving command\n")); FILE_LOG(logDEBUG1, ("Done with program receiving command\n"));
if (isControlServer) { if (isControlServer) {
basictests(debugflag); basictests(debugflag);
@ -2493,7 +2494,7 @@ int reset_fpga(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Reset FPGA\n")); FILE_LOG(logDEBUG1, ("Reset FPGA\n"));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
#else #else
@ -2521,7 +2522,7 @@ int power_chip(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Powering chip to %d\n", arg)); FILE_LOG(logDEBUG1, ("Powering chip to %d\n", arg));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2529,7 +2530,7 @@ int power_chip(int file_des) {
// set & get // set & get
if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) { if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) {
retval = powerChip(arg); retval = powerChip(arg);
FILE_LOG(logDEBUG5, ("Power chip: %d\n", retval)); FILE_LOG(logDEBUG1, ("Power chip: %d\n", retval));
validate(arg, retval, "power on/off chip", 0); validate(arg, retval, "power on/off chip", 0);
// narrow down error when powering on // narrow down error when powering on
if (ret == FAIL && arg > 0) { if (ret == FAIL && arg > 0) {
@ -2554,7 +2555,7 @@ int set_activate(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting activate mode to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting activate mode to %d\n", arg));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
@ -2562,7 +2563,7 @@ int set_activate(int file_des) {
// set & get // set & get
if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) { if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) {
retval = activate(arg); retval = activate(arg);
FILE_LOG(logDEBUG5, ("Activate: %d\n", retval)); FILE_LOG(logDEBUG1, ("Activate: %d\n", retval));
validate(arg, retval, "set activate", 0); validate(arg, retval, "set activate", 0);
} }
#endif #endif
@ -2576,7 +2577,7 @@ int prepare_acquisition(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Preparing Acquisition\n")); FILE_LOG(logDEBUG1, ("Preparing Acquisition\n"));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
#else #else
@ -2604,7 +2605,7 @@ int threshold_temp(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting threshold temperature to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting threshold temperature to %d\n", arg));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2620,7 +2621,7 @@ int threshold_temp(int file_des) {
// valid temp // valid temp
else { else {
retval = setThresholdTemperature(arg); retval = setThresholdTemperature(arg);
FILE_LOG(logDEBUG5, ("Threshold temperature: %d\n", retval)); FILE_LOG(logDEBUG1, ("Threshold temperature: %d\n", retval));
validate(arg, retval, "set threshold temperature", 0); validate(arg, retval, "set threshold temperature", 0);
} }
} }
@ -2638,7 +2639,7 @@ int temp_control(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting temperature control to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting temperature control to %d\n", arg));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2646,7 +2647,7 @@ int temp_control(int file_des) {
// set & get // set & get
if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) { if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) {
retval = setTemperatureControl(arg); retval = setTemperatureControl(arg);
FILE_LOG(logDEBUG5, ("Temperature control: %d\n", retval)); FILE_LOG(logDEBUG1, ("Temperature control: %d\n", retval));
validate(arg, retval, "set temperature control", 0); validate(arg, retval, "set temperature control", 0);
} }
#endif #endif
@ -2664,7 +2665,7 @@ int temp_event(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting temperature event to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting temperature event to %d\n", arg));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2672,7 +2673,7 @@ int temp_event(int file_des) {
// set & get // set & get
if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) { if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) {
retval = setTemperatureEvent(arg); retval = setTemperatureEvent(arg);
FILE_LOG(logDEBUG5, ("Temperature event: %d\n", retval)); FILE_LOG(logDEBUG1, ("Temperature event: %d\n", retval));
validate(arg, retval, "set temperature event", 0); validate(arg, retval, "set temperature event", 0);
} }
#endif #endif
@ -2691,7 +2692,7 @@ int auto_comp_disable(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting Auto comp disable to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting Auto comp disable to %d\n", arg));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2699,7 +2700,7 @@ int auto_comp_disable(int file_des) {
// set & get // set & get
if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) { if ((arg == -1) || ((arg != -1) && (Server_VerifyLock() == OK))) {
retval = autoCompDisable(arg); retval = autoCompDisable(arg);
FILE_LOG(logDEBUG5, ("Auto comp disable: %d\n", retval)); FILE_LOG(logDEBUG1, ("Auto comp disable: %d\n", retval));
validate(arg, retval, "set auto comp disable", 0); validate(arg, retval, "set auto comp disable", 0);
} }
#endif #endif
@ -2718,7 +2719,7 @@ int storage_cell_start(int file_des) {
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0) if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError(); return printSocketReadError();
FILE_LOG(logDEBUG5, ("Setting Storage cell start to %d\n", arg)); FILE_LOG(logDEBUG1, ("Setting Storage cell start to %d\n", arg));
#ifndef JUNGFRAUD #ifndef JUNGFRAUD
functionNotImplemented(); functionNotImplemented();
@ -2731,7 +2732,7 @@ int storage_cell_start(int file_des) {
FILE_LOG(logERROR, (mess)); FILE_LOG(logERROR, (mess));
} else { } else {
retval = selectStoragecellStart(arg); retval = selectStoragecellStart(arg);
FILE_LOG(logDEBUG5, ("Storage cell start: %d\n", retval)); FILE_LOG(logDEBUG1, ("Storage cell start: %d\n", retval));
validate(arg, retval, "set storage cell start", 0); validate(arg, retval, "set storage cell start", 0);
} }
#endif #endif
@ -2751,7 +2752,7 @@ int check_version(int file_des) {
// check software- firmware compatibility and basic tests // check software- firmware compatibility and basic tests
if (isControlServer) { if (isControlServer) {
FILE_LOG(logDEBUG5, ("Checking software-firmware compatibility and basic test result\n")); FILE_LOG(logDEBUG1, ("Checking software-firmware compatibility and basic test result\n"));
// check if firmware check is done // check if firmware check is done
if (!isFirmwareCheckDone()) { if (!isFirmwareCheckDone()) {
@ -2775,7 +2776,7 @@ int check_version(int file_des) {
} }
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5, ("Checking versioning compatibility with value %d\n",arg)); FILE_LOG(logDEBUG1, ("Checking versioning compatibility with value %d\n",arg));
int64_t client_requiredVersion = arg; int64_t client_requiredVersion = arg;
int64_t det_apiVersion = getDetectorId(CLIENT_SOFTWARE_API_VERSION); int64_t det_apiVersion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
@ -2811,7 +2812,7 @@ int software_trigger(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG5, ("Software Trigger\n")); FILE_LOG(logDEBUG1, ("Software Trigger\n"));
#ifndef EIGERD #ifndef EIGERD
functionNotImplemented(); functionNotImplemented();
#else #else
@ -2822,7 +2823,7 @@ int software_trigger(int file_des) {
sprintf(mess, "Could not send software trigger\n"); sprintf(mess, "Could not send software trigger\n");
FILE_LOG(logERROR,(mess)); FILE_LOG(logERROR,(mess));
} }
FILE_LOG(logDEBUG5, ("Software trigger ret: %d\n", ret)); FILE_LOG(logDEBUG1, ("Software trigger ret: %d\n", ret));
} }
#endif #endif
return Server_SendResult(file_des, INT32, 1 , NULL, 0); return Server_SendResult(file_des, INT32, 1 , NULL, 0);

41
slsDetectorSoftware/sharedMemory/SharedMemory.cpp
View File

@ -1,6 +1,7 @@
#include "SharedMemory.h" #include "SharedMemory.h"
#include "sls_detector_exceptions.h" #include "sls_detector_exceptions.h"
#include "ansi.h" #include "ansi.h"
#include "logger.h"
#include <iostream> #include <iostream>
#include <stdio.h> // printf #include <stdio.h> // printf
@ -51,15 +52,13 @@ void* SharedMemory::CreateSharedMemory(size_t sz){
// create // create
fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR); fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
if (fd < 0) { if (fd < 0) {
cprintf(RED, "Error: Create shared memory %s failed: %s\n", FILE_LOG(logERROR) << "Create shared memory " << name << " failed: " << strerror(errno);
name.c_str(), strerror(errno));
throw SharedMemoryException(); throw SharedMemoryException();
} }
// resize // resize
if (ftruncate(fd, sz) < 0) { if (ftruncate(fd, sz) < 0) {
cprintf(RED, "Error: Create shared memory %s failed at ftruncate: %s\n", FILE_LOG(logERROR) << "Create shared memory " << name << " failed at ftruncate: " << strerror(errno);
name.c_str(), strerror(errno));
close(fd); close(fd);
RemoveSharedMemory(); RemoveSharedMemory();
throw SharedMemoryException(); throw SharedMemoryException();
@ -67,7 +66,7 @@ void* SharedMemory::CreateSharedMemory(size_t sz){
// map // map
void* addr = MapSharedMemory(sz); void* addr = MapSharedMemory(sz);
printf("Shared memory created %s \n", name.c_str()); FILE_LOG(logINFO) << "Shared memory created " << name;
return addr; return addr;
} }
@ -75,8 +74,7 @@ void* SharedMemory::OpenSharedMemory(size_t sz){
// open // open
fd = shm_open(name.c_str(), O_RDWR, 0); fd = shm_open(name.c_str(), O_RDWR, 0);
if (fd < 0) { if (fd < 0) {
cprintf(RED, "Error: Open existing shared memory %s failed: %s\n", FILE_LOG(logERROR) << "Open existing shared memory " << name << " failed: " << strerror(errno);
name.c_str(), strerror(errno));
throw SharedMemoryException(); throw SharedMemoryException();
} }
@ -86,8 +84,7 @@ void* SharedMemory::OpenSharedMemory(size_t sz){
void SharedMemory::UnmapSharedMemory(void* addr) { void SharedMemory::UnmapSharedMemory(void* addr) {
if (munmap(addr, shmSize) < 0) { if (munmap(addr, shmSize) < 0) {
cprintf(RED, "Error: Unmapping shared memory %s failed: %s\n", FILE_LOG(logERROR) << "Unmapping shared memory " << name << " failed: " << strerror(errno);
name.c_str(), strerror(errno));
close(fd); close(fd);
throw SharedMemoryException(); throw SharedMemoryException();
} }
@ -98,19 +95,17 @@ void SharedMemory::RemoveSharedMemory() {
// silent exit if shm did not exist anyway // silent exit if shm did not exist anyway
if (errno == ENOENT) if (errno == ENOENT)
return; return;
cprintf(RED, "Error: Free Shared Memory %s Failed: %s\n", FILE_LOG(logERROR) << "Free Shared Memory " << name << " Failed: " << strerror(errno);
name.c_str(), strerror(errno));
throw SharedMemoryException(); throw SharedMemoryException();
} }
printf("Shared memory deleted %s \n", name.c_str()); FILE_LOG(logINFO) << "Shared memory deleted " << name;
} }
void* SharedMemory::MapSharedMemory(size_t sz) { void* SharedMemory::MapSharedMemory(size_t sz) {
void* addr = mmap(NULL, sz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); void* addr = mmap(NULL, sz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (addr == MAP_FAILED) { if (addr == MAP_FAILED) {
cprintf(RED, "Error: Mapping shared memory %s failed: %s\n", FILE_LOG(logERROR) << "Mapping shared memory " << name << " failed: " << strerror(errno);
name.c_str(), strerror(errno));
close(fd); close(fd);
throw SharedMemoryException(); throw SharedMemoryException();
} }
@ -138,10 +133,9 @@ std::string SharedMemory::ConstructSharedMemoryName(int multiId, int slsId) {
std::string temp = ss.str(); std::string temp = ss.str();
if (temp.length() > NAME_MAX) { if (temp.length() > NAME_MAX) {
cprintf(RED, "Error: Shared memory initialization failed. " FILE_LOG(logERROR) << "Shared memory initialization failed. " <<
"%s has %lu characters. \n" temp << " has " << temp.length() << " characters. \n"
"Maximum is %d. Change the environment variable %s\n", "Maximum is " << NAME_MAX << ". Change the environment variable " << SHM_ENV_NAME;
temp.c_str(), temp.length(), NAME_MAX, SHM_ENV_NAME);
throw SharedMemoryException(); throw SharedMemoryException();
} }
return temp; return temp;
@ -152,8 +146,8 @@ int SharedMemory::VerifySizeMatch(size_t expectedSize) {
struct stat sb; struct stat sb;
// could not fstat // could not fstat
if (fstat(fd, &sb) < 0) { if (fstat(fd, &sb) < 0) {
cprintf(RED, "Error: Could not verify existing shared memory %s size match " FILE_LOG(logERROR) << "Could not verify existing shared memory " << name << " size match "
"(could not fstat): %s\n", name.c_str(), strerror(errno)); "(could not fstat): " << strerror(errno);
close(fd); close(fd);
throw SharedMemoryException(); throw SharedMemoryException();
} }
@ -161,11 +155,8 @@ int SharedMemory::VerifySizeMatch(size_t expectedSize) {
//size does not match //size does not match
long unsigned int sz = (long unsigned int)sb.st_size; long unsigned int sz = (long unsigned int)sb.st_size;
if (sz != expectedSize) { if (sz != expectedSize) {
cprintf(RED, "Warning: Existing shared memory %s size does not match.\n", FILE_LOG(logERROR) << "Existing shared memory " << name << " size does not match";
name.c_str()); FILE_LOG(logDEBUG1) << "Expected " << expectedSize << ", found " << sz;
#ifdef VERBOSE
cprintf(RED, " Expected %ld, found %ld\n", expectedSize, sz);
#endif
throw SharedMemoryException(); throw SharedMemoryException();
return 1; return 1;
} }

556
slsDetectorSoftware/slsDetector/slsDetector.cpp
View File

File diff suppressed because it is too large Load Diff

2
slsDetectorSoftware/slsDetector/slsDetectorCommand.cpp
View File

@ -2726,7 +2726,7 @@ string slsDetectorCommand::cmdRateCorr(int narg, char *args[], int action, int d
sscanf(args[1], "%ld",&ival); sscanf(args[1], "%ld",&ival);
myDet->setRateCorrection(ival, detPos); myDet->setRateCorrection(ival, detPos);
} }
sprintf(answer,"%lld",myDet->getRateCorrection(detPos)); sprintf(answer,"%ld",myDet->getRateCorrection(detPos));
return string(answer); return string(answer);
} }

10
slsReceiverSoftware/include/BinaryFileStatic.h
View File

@ -123,12 +123,14 @@ class BinaryFileStatic {
{ {
if(!owenable){ if(!owenable){
if (NULL == (fd = fopen((const char *) fname.c_str(), "wx"))){ if (NULL == (fd = fopen((const char *) fname.c_str(), "wx"))){
cprintf(RED,"Error in creating binary master file (without overwrite enable) %s\n",fname.c_str()); FILE_LOG(logERROR) << "Could not create binary master file "
"(without overwrite enable) " << fname;
fd = 0; fd = 0;
return 1; return 1;
} }
}else if (NULL == (fd = fopen((const char *) fname.c_str(), "w"))){ }else if (NULL == (fd = fopen((const char *) fname.c_str(), "w"))){
cprintf(RED,"Error in creating binary master file (with overwrite enable) %s\n",fname.c_str()); FILE_LOG(logERROR) << "Could not create binary master file "
"(with overwrite enable) " << fname;
fd = 0; fd = 0;
return 1; return 1;
} }
@ -179,8 +181,8 @@ class BinaryFileStatic {
(long long int)acquisitionPeriod, (long long int)acquisitionPeriod,
ctime(&t)); ctime(&t));
if (strlen(message) > MAX_MASTER_FILE_LENGTH) { if (strlen(message) > MAX_MASTER_FILE_LENGTH) {
cprintf(RED,"Master File Size %d is greater than max str size %d\n", FILE_LOG(logERROR) << "Master File Size " << strlen(message) <<
(int)strlen(message), MAX_MASTER_FILE_LENGTH); " is greater than max str size " << MAX_MASTER_FILE_LENGTH;
return 1; return 1;
} }

30
slsReceiverSoftware/include/File.h
View File

@ -53,7 +53,7 @@ class File : private virtual slsDetectorDefs {
/** /**
* Print all member values * Print all member values
*/ */
virtual void PrintMembers(); virtual void PrintMembers(TLogLevel level = logDEBUG1);
/** /**
* Get Type * Get Type
@ -85,8 +85,8 @@ class File : private virtual slsDetectorDefs {
* @returns OK or FAIL * @returns OK or FAIL
*/ */
virtual int CreateFile(uint64_t fnum){ virtual int CreateFile(uint64_t fnum){
cprintf(RED,"This is a generic function CreateFile that should be " FILE_LOG(logERROR) << "This is a generic function CreateFile that should be "
"overloaded by a derived class\n"); "overloaded by a derived class";
return OK; return OK;
} }
@ -94,16 +94,16 @@ class File : private virtual slsDetectorDefs {
* Close Current File * Close Current File
*/ */
virtual void CloseCurrentFile() { virtual void CloseCurrentFile() {
cprintf(RED,"This is a generic function CloseCurrentFile that should be " FILE_LOG(logERROR) << "This is a generic function CloseCurrentFile that should be "
"overloaded by a derived class\n"); "overloaded by a derived class";
} }
/** /**
* Close Files * Close Files
*/ */
virtual void CloseAllFiles() { virtual void CloseAllFiles() {
cprintf(RED,"This is a generic function that should be overloaded " FILE_LOG(logERROR) << "This is a generic function that should be overloaded "
"by a derived class\n"); "by a derived class";
} }
/** /**
@ -114,8 +114,8 @@ class File : private virtual slsDetectorDefs {
* @param OK or FAIL * @param OK or FAIL
*/ */
virtual int WriteToFile(char* buffer, int buffersize, uint64_t fnum, uint32_t nump) { virtual int WriteToFile(char* buffer, int buffersize, uint64_t fnum, uint32_t nump) {
cprintf(RED,"This is a generic function WriteToFile that " FILE_LOG(logERROR) << "This is a generic function WriteToFile that "
"should be overloaded by a derived class\n"); "should be overloaded by a derived class";
return FAIL; return FAIL;
} }
@ -134,8 +134,8 @@ class File : private virtual slsDetectorDefs {
virtual int CreateMasterFile(bool en, uint32_t size, virtual int CreateMasterFile(bool en, uint32_t size,
uint32_t nx, uint32_t ny, uint64_t at, uint64_t st, uint32_t nx, uint32_t ny, uint64_t at, uint64_t st,
uint64_t sp, uint64_t ap) { uint64_t sp, uint64_t ap) {
cprintf(RED,"This is a generic function CreateMasterFile that " FILE_LOG(logERROR) << "This is a generic function CreateMasterFile that "
"should be overloaded by a derived class\n"); "should be overloaded by a derived class";
return OK; return OK;
} }
@ -146,8 +146,8 @@ class File : private virtual slsDetectorDefs {
* @param ny number of pixels in y direction * @param ny number of pixels in y direction
*/ */
virtual void SetNumberofPixels(uint32_t nx, uint32_t ny) { virtual void SetNumberofPixels(uint32_t nx, uint32_t ny) {
cprintf(RED,"This is a generic function SetNumberofPixels that " FILE_LOG(logERROR) << "This is a generic function SetNumberofPixels that "
"should be overloaded by a derived class\n"); "should be overloaded by a derived class";
} }
/** /**
@ -156,8 +156,8 @@ class File : private virtual slsDetectorDefs {
* @param numf number of images caught * @param numf number of images caught
*/ */
virtual void EndofAcquisition(bool anyPacketsCaught, uint64_t numf) { virtual void EndofAcquisition(bool anyPacketsCaught, uint64_t numf) {
cprintf(RED,"This is a generic function EndofAcquisition that " FILE_LOG(logERROR) << "This is a generic function EndofAcquisition that "
"should be overloaded by a derived class\n"); "should be overloaded by a derived class";
} }
protected: protected:

62
slsReceiverSoftware/include/GeneralData.h
View File

@ -161,7 +161,7 @@ public:
* @param i ROI * @param i ROI
*/ */
virtual void SetROI(std::vector<slsDetectorDefs::ROI> i) { virtual void SetROI(std::vector<slsDetectorDefs::ROI> i) {
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); FILE_LOG(logERROR) << "This is a generic function that should be overloaded by a derived class";
}; };
/** /**
@ -171,7 +171,7 @@ public:
* @returns adc configured * @returns adc configured
*/ */
virtual const int GetAdcConfigured(int index, std::vector<slsDetectorDefs::ROI>* i) const{ virtual const int GetAdcConfigured(int index, std::vector<slsDetectorDefs::ROI>* i) const{
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); FILE_LOG(logERROR) << "This is a generic function that should be overloaded by a derived class";
return 0; return 0;
}; };
@ -181,7 +181,7 @@ public:
* @param tgEnable true if 10GbE is enabled, else false * @param tgEnable true if 10GbE is enabled, else false
*/ */
virtual void SetDynamicRange(int dr, bool tgEnable) { virtual void SetDynamicRange(int dr, bool tgEnable) {
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); FILE_LOG(logERROR) << "This is a generic function that should be overloaded by a derived class";
}; };
/** /**
@ -190,7 +190,7 @@ public:
* @param dr dynamic range * @param dr dynamic range
*/ */
virtual void SetTenGigaEnable(bool tgEnable, int dr) { virtual void SetTenGigaEnable(bool tgEnable, int dr) {
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); FILE_LOG(logERROR) << "This is a generic function that should be overloaded by a derived class";
}; };
/** /**
@ -199,7 +199,7 @@ public:
* @param nroich number of channels in roi * @param nroich number of channels in roi
*/ */
virtual void setNumberofSamples(const uint64_t ns, uint32_t nroich) { virtual void setNumberofSamples(const uint64_t ns, uint32_t nroich) {
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); FILE_LOG(logERROR) << "This is a generic function that should be overloaded by a derived class";
}; };
/** /**
@ -207,38 +207,38 @@ public:
* @param enable true if gap pixels enable, else false * @param enable true if gap pixels enable, else false
*/ */
virtual void SetGapPixelsEnable(bool b, int dr) { virtual void SetGapPixelsEnable(bool b, int dr) {
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); FILE_LOG(logERROR) << "This is a generic function that should be overloaded by a derived class";
}; };
/** /**
* Print all variables * Print all variables
*/ */
virtual void Print() const { virtual void Print(TLogLevel level = logDEBUG1) const {
FILE_LOG(logDEBUG) << "\n\nDetector Data Variables:"; FILE_LOG(level) << "\n\nDetector Data Variables:";
FILE_LOG(logDEBUG) << "myDetectorType: " << slsDetectorDefs::getDetectorType(myDetectorType); FILE_LOG(level) << "myDetectorType: " << slsDetectorDefs::getDetectorType(myDetectorType);
FILE_LOG(logDEBUG) << "Pixels X: " << nPixelsX; FILE_LOG(level) << "Pixels X: " << nPixelsX;
FILE_LOG(logDEBUG) << "Pixels Y: " << nPixelsY; FILE_LOG(level) << "Pixels Y: " << nPixelsY;
FILE_LOG(logDEBUG) << "Empty Header: " << emptyHeader; FILE_LOG(level) << "Empty Header: " << emptyHeader;
FILE_LOG(logDEBUG) << "Header Size in Packet: " << headerSizeinPacket; FILE_LOG(level) << "Header Size in Packet: " << headerSizeinPacket;
FILE_LOG(logDEBUG) << "Data Size: " << dataSize; FILE_LOG(level) << "Data Size: " << dataSize;
FILE_LOG(logDEBUG) << "Packet Size: " << packetSize; FILE_LOG(level) << "Packet Size: " << packetSize;
FILE_LOG(logDEBUG) << "Packets per Frame: " << packetsPerFrame; FILE_LOG(level) << "Packets per Frame: " << packetsPerFrame;
FILE_LOG(logDEBUG) << "Image Size: " << imageSize; FILE_LOG(level) << "Image Size: " << imageSize;
FILE_LOG(logDEBUG) << "Frame Index Mask: " << frameIndexMask; FILE_LOG(level) << "Frame Index Mask: " << frameIndexMask;
FILE_LOG(logDEBUG) << "Frame Index Offset: " << frameIndexOffset; FILE_LOG(level) << "Frame Index Offset: " << frameIndexOffset;
FILE_LOG(logDEBUG) << "Packet Index Mask: " << packetIndexMask; FILE_LOG(level) << "Packet Index Mask: " << packetIndexMask;
FILE_LOG(logDEBUG) << "Packet Index Offset: " << packetIndexOffset; FILE_LOG(level) << "Packet Index Offset: " << packetIndexOffset;
FILE_LOG(logDEBUG) << "Max Frames Per File: " << maxFramesPerFile; FILE_LOG(level) << "Max Frames Per File: " << maxFramesPerFile;
FILE_LOG(logDEBUG) << "Fifo Buffer Header Size: " << fifoBufferHeaderSize; FILE_LOG(level) << "Fifo Buffer Header Size: " << fifoBufferHeaderSize;
FILE_LOG(logDEBUG) << "Default Fifo Depth: " << defaultFifoDepth; FILE_LOG(level) << "Default Fifo Depth: " << defaultFifoDepth;
FILE_LOG(logDEBUG) << "Threads Per Receiver: " << threadsPerReceiver; FILE_LOG(level) << "Threads Per Receiver: " << threadsPerReceiver;
FILE_LOG(logDEBUG) << "Header Packet Size: " << headerPacketSize; FILE_LOG(level) << "Header Packet Size: " << headerPacketSize;
FILE_LOG(logDEBUG) << "Complete Pixels X: " << nPixelsXComplete; FILE_LOG(level) << "Complete Pixels X: " << nPixelsXComplete;
FILE_LOG(logDEBUG) << "Complete Pixels Y: " << nPixelsYComplete; FILE_LOG(level) << "Complete Pixels Y: " << nPixelsYComplete;
FILE_LOG(logDEBUG) << "Complete Image Size: " << imageSizeComplete; FILE_LOG(level) << "Complete Image Size: " << imageSizeComplete;
FILE_LOG(logDEBUG) << "Standard Header: " << standardheader; FILE_LOG(level) << "Standard Header: " << standardheader;
FILE_LOG(logDEBUG) << "UDP Socket Buffer Size: " << defaultUdpSocketBufferSize; FILE_LOG(level) << "UDP Socket Buffer Size: " << defaultUdpSocketBufferSize;
}; };
}; };

2
slsReceiverSoftware/include/HDF5File.h
View File

@ -55,7 +55,7 @@ class HDF5File : private virtual slsDetectorDefs, public File, public HDF5FileSt
/** /**
* Print all member values * Print all member values
*/ */
void PrintMembers(); void PrintMembers(TLogLevel level = logDEBUG1);
/** /**
* Set Number of pixels * Set Number of pixels

84
slsReceiverSoftware/include/HDF5FileStatic.h
View File

@ -112,7 +112,7 @@ public:
fd = 0; fd = 0;
} }
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in closing HDF5 handles of index %d\n", ind); FILE_LOG(logERROR) << "Could not close HDF5 handles of index " << ind;
error.printErrorStack(); error.printErrorStack();
} }
} }
@ -130,7 +130,7 @@ public:
fd = 0; fd = 0;
} }
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in closing master HDF5 handles\n"); FILE_LOG(logERROR) << "Could not close master HDF5 handles";
error.printErrorStack(); error.printErrorStack();
} }
} }
@ -144,7 +144,7 @@ public:
{ {
if(fd) { if(fd) {
if (H5Fclose(fd) < 0 ) if (H5Fclose(fd) < 0 )
cprintf(RED,"Error in closing virtual HDF5 handles\n"); FILE_LOG(logERROR) << "Could not close virtual HDF5 handles";
fd = 0; fd = 0;
} }
} }
@ -177,7 +177,7 @@ public:
memspace.close(); memspace.close();
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in writing to file in object %d\n",ind); FILE_LOG(logERROR) << "Could not write to file in object " << ind;
error.printErrorStack(); error.printErrorStack();
return 1; return 1;
} }
@ -239,7 +239,7 @@ public:
}i=14; }i=14;
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in writing parameters (index:%d) to file in object %d\n", i, ind); FILE_LOG(logERROR) << "Could not write parameters (index:" << i << ") to file in object " << ind;
error.printErrorStack(); error.printErrorStack();
return 1; return 1;
} }
@ -282,7 +282,7 @@ public:
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in extending dataset in object %d\n",ind); FILE_LOG(logERROR) << "Could not extend dataset in object " << ind;
error.printError(); error.printError();
return 1; return 1;
} }
@ -417,7 +417,7 @@ public:
fd->close(); fd->close();
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in creating master HDF5 handles\n"); FILE_LOG(logERROR) << "Could not create master HDF5 handles";
error.printErrorStack(); error.printErrorStack();
if (fd) fd->close(); if (fd) fd->close();
return 1; return 1;
@ -521,7 +521,7 @@ public:
} }
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in creating HDF5 handles in object %d\n",ind); FILE_LOG(logERROR) << "Could not create HDF5 handles in object " << ind;
error.printErrorStack(); error.printErrorStack();
if (fd) fd->close(); if (fd) fd->close();
return 1; return 1;
@ -571,36 +571,36 @@ public:
hid_t dfal = H5Pcreate (H5P_FILE_ACCESS); hid_t dfal = H5Pcreate (H5P_FILE_ACCESS);
if (dfal < 0) if (dfal < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating file access property for virtual file ") std::string("Could not create file access property for virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
if (H5Pset_fclose_degree (dfal, H5F_CLOSE_STRONG) < 0) if (H5Pset_fclose_degree (dfal, H5F_CLOSE_STRONG) < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in setting strong file close degree for virtual file ") std::string("Could not set strong file close degree for virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
fd = H5Fcreate( virtualFileName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, dfal); fd = H5Fcreate( virtualFileName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, dfal);
if (fd < 0) if (fd < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating virtual file ") + virtualFileName + std::string("\n")); std::string("Could not create virtual file ") + virtualFileName + std::string("\n"));
//attributes - version //attributes - version
hid_t dataspace_attr = H5Screate (H5S_SCALAR); hid_t dataspace_attr = H5Screate (H5S_SCALAR);
if (dataspace_attr < 0) if (dataspace_attr < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating dataspace for attribute in virtual file ") std::string("Could not create dataspace for attribute in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
hid_t attrid = H5Acreate2 (fd, "version", H5T_NATIVE_DOUBLE, dataspace_attr, H5P_DEFAULT, H5P_DEFAULT); hid_t attrid = H5Acreate2 (fd, "version", H5T_NATIVE_DOUBLE, dataspace_attr, H5P_DEFAULT, H5P_DEFAULT);
if (attrid < 0) if (attrid < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating attribute in virtual file ") std::string("Could not create attribute in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
double attr_data = version; double attr_data = version;
if (H5Awrite (attrid, H5T_NATIVE_DOUBLE, &attr_data) < 0) if (H5Awrite (attrid, H5T_NATIVE_DOUBLE, &attr_data) < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in writing attribute in virtual file ") std::string("Could not write attribute in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
if (H5Aclose (attrid) < 0) if (H5Aclose (attrid) < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in closing attribute in virtual file ") std::string("Could not close attribute in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
@ -609,13 +609,13 @@ public:
hid_t vdsDataspace = H5Screate_simple(3, vdsdims ,NULL); hid_t vdsDataspace = H5Screate_simple(3, vdsdims ,NULL);
if (vdsDataspace < 0) if (vdsDataspace < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating virtual dataspace in virtual file ") std::string("Could not create virtual dataspace in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
hsize_t vdsdims_para[2] = {numf, (unsigned int) numDety * numDetz}; hsize_t vdsdims_para[2] = {numf, (unsigned int) numDety * numDetz};
hid_t vdsDataspace_para = H5Screate_simple(2, vdsdims_para, NULL); hid_t vdsDataspace_para = H5Screate_simple(2, vdsdims_para, NULL);
if (vdsDataspace_para < 0) if (vdsDataspace_para < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating virtual dataspace (parameters) in virtual file ") std::string("Could not create virtual dataspace (parameters) in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
@ -623,23 +623,23 @@ public:
hid_t dcpl = H5Pcreate (H5P_DATASET_CREATE); hid_t dcpl = H5Pcreate (H5P_DATASET_CREATE);
if (dcpl < 0) if (dcpl < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating file creation properties in virtual file ") std::string("Could not create file creation properties in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
int fill_value = -1; int fill_value = -1;
if (H5Pset_fill_value (dcpl, GetDataTypeinC(dataType), &fill_value) < 0) if (H5Pset_fill_value (dcpl, GetDataTypeinC(dataType), &fill_value) < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating fill value in virtual file ") std::string("Could not create fill value in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
hid_t dcpl_para[parameterNames.size()]; hid_t dcpl_para[parameterNames.size()];
for (unsigned int i = 0; i < parameterNames.size(); ++i) { for (unsigned int i = 0; i < parameterNames.size(); ++i) {
dcpl_para[i] = H5Pcreate (H5P_DATASET_CREATE); dcpl_para[i] = H5Pcreate (H5P_DATASET_CREATE);
if (dcpl_para[i] < 0) if (dcpl_para[i] < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating file creation properties (parameters) in virtual file ") std::string("Could not create file creation properties (parameters) in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
if (H5Pset_fill_value (dcpl_para[i], GetDataTypeinC(parameterDataTypes[i]), &fill_value) < 0) if (H5Pset_fill_value (dcpl_para[i], GetDataTypeinC(parameterDataTypes[i]), &fill_value) < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating fill value (parameters) in virtual file ") std::string("Could not create fill value (parameters) in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
} }
@ -661,13 +661,13 @@ public:
//setect hyperslabs //setect hyperslabs
if (H5Sselect_hyperslab (vdsDataspace, H5S_SELECT_SET, offset, NULL, count, NULL) < 0) { if (H5Sselect_hyperslab (vdsDataspace, H5S_SELECT_SET, offset, NULL, count, NULL) < 0) {
cprintf(RED,"could not select hyperslab\n"); FILE_LOG(logERROR) << "Could not select hyperslab";
error = true; error = true;
break; break;
} }
if (H5Sselect_hyperslab (vdsDataspace_para, H5S_SELECT_SET, if (H5Sselect_hyperslab (vdsDataspace_para, H5S_SELECT_SET,
offset_para, NULL, count_para, NULL) < 0) { offset_para, NULL, count_para, NULL) < 0) {
cprintf(RED,"could not select hyperslab for parameters\n"); FILE_LOG(logERROR) << "Could not select hyperslab for parameters";
error = true; error = true;
break; break;
} }
@ -696,20 +696,20 @@ public:
hid_t srcDataspace = H5Screate_simple(3, srcdims, srcdimsmax); hid_t srcDataspace = H5Screate_simple(3, srcdims, srcdimsmax);
if (srcDataspace < 0) if (srcDataspace < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating source dataspace in virtual file ") std::string("Could not create source dataspace in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
hsize_t srcdims_para[1] = {nDimx}; hsize_t srcdims_para[1] = {nDimx};
hsize_t srcdimsmax_para[1] = {H5S_UNLIMITED}; hsize_t srcdimsmax_para[1] = {H5S_UNLIMITED};
hid_t srcDataspace_para = H5Screate_simple(1, srcdims_para, srcdimsmax_para); hid_t srcDataspace_para = H5Screate_simple(1, srcdims_para, srcdimsmax_para);
if (srcDataspace_para < 0) if (srcDataspace_para < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating source dataspace (parameters) in virtual file ") std::string("Could not create source dataspace (parameters) in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
//mapping //mapping
if (H5Pset_virtual(dcpl, vdsDataspace, relative_srcFileName.c_str(), if (H5Pset_virtual(dcpl, vdsDataspace, relative_srcFileName.c_str(),
srcDatasetName.c_str(), srcDataspace) < 0) { srcDatasetName.c_str(), srcDataspace) < 0) {
cprintf(RED,"could not set mapping for paramter 1\n"); FILE_LOG(logERROR) << "Could not set mapping for paramter 1";
error = true; error = true;
break; break;
} }
@ -717,7 +717,7 @@ public:
for (unsigned int k = 0; k < parameterNames.size(); ++k) { for (unsigned int k = 0; k < parameterNames.size(); ++k) {
if (H5Pset_virtual(dcpl_para[k], vdsDataspace_para, relative_srcFileName.c_str(), if (H5Pset_virtual(dcpl_para[k], vdsDataspace_para, relative_srcFileName.c_str(),
parameterNames[k], srcDataspace_para) < 0) { parameterNames[k], srcDataspace_para) < 0) {
cprintf(RED,"could not set mapping for paramter %d\n", k); FILE_LOG(logERROR) << "Could not set mapping for paramter " << k;
error = true; error = true;
break; break;
} }
@ -736,7 +736,7 @@ public:
} }
if (error) if (error)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in mapping files in virtual file ") std::string("Could not map files in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
//dataset //dataset
@ -745,7 +745,7 @@ public:
GetDataTypeinC(dataType), vdsDataspace, H5P_DEFAULT, dcpl, H5P_DEFAULT); GetDataTypeinC(dataType), vdsDataspace, H5P_DEFAULT, dcpl, H5P_DEFAULT);
if (vdsdataset < 0) if (vdsdataset < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating virutal dataset in virtual file ") std::string("Could not create virutal dataset in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
@ -757,7 +757,7 @@ public:
H5P_DEFAULT, dcpl_para[i], H5P_DEFAULT); H5P_DEFAULT, dcpl_para[i], H5P_DEFAULT);
if (vdsdataset_para < 0) if (vdsdataset_para < 0)
return CloseFileOnError(fd, return CloseFileOnError(fd,
std::string("Error in creating virutal dataset (parameters) in virtual file ") std::string("Could not create virutal dataset (parameters) in virtual file ")
+ virtualFileName + std::string("\n")); + virtualFileName + std::string("\n"));
} }
@ -798,7 +798,7 @@ public:
data_out = (T*)malloc(sizeof(T)*(nDimx*nDimy*nDimz)); data_out = (T*)malloc(sizeof(T)*(nDimx*nDimy*nDimz));
break; break;
default: default:
cprintf(RED,"invalid rank. Options: 2 or 3\n"); FILE_LOG(logERROR) << "Invalid rank. Options: 2 or 3";
return 0; return 0;
} }
if (datatype == PredType::STD_U16LE) { if (datatype == PredType::STD_U16LE) {
@ -810,7 +810,7 @@ public:
} else if (datatype == PredType::STD_U8LE) { } else if (datatype == PredType::STD_U8LE) {
FILE_LOG(logINFO) << "datatype:8"; FILE_LOG(logINFO) << "datatype:8";
} else { } else {
FILE_LOG(logERROR) << "unknown datatype"; FILE_LOG(logERROR) << "Unknown datatype: " << datetype;
return 1; return 1;
} }
FILE_LOG(logINFO) << "owenable:" << (owenable?1:0) << std::endl FILE_LOG(logINFO) << "owenable:" << (owenable?1:0) << std::endl
@ -861,7 +861,7 @@ public:
newfd->close(); newfd->close();
oldfd->close(); oldfd->close();
} catch(Exception error){ } catch(Exception error){
cprintf(RED,"Error in copying virtual files\n"); FILE_LOG(logERROR) << "Could not copy virtual files";
error.printErrorStack(); error.printErrorStack();
free(data_out); free(data_out);
oldfd->close(); oldfd->close();
@ -890,20 +890,20 @@ public:
hid_t dfal = H5Pcreate (H5P_FILE_ACCESS); hid_t dfal = H5Pcreate (H5P_FILE_ACCESS);
if (dfal < 0) if (dfal < 0)
return CloseFileOnError( vfd, std::string("Error in creating file access property for link\n")); return CloseFileOnError( vfd, std::string("Could not create file access property for link\n"));
if (H5Pset_fclose_degree (dfal, H5F_CLOSE_STRONG) < 0) if (H5Pset_fclose_degree (dfal, H5F_CLOSE_STRONG) < 0)
return CloseFileOnError( vfd, std::string("Error in setting strong file close degree for link\n")); return CloseFileOnError( vfd, std::string("Could not set strong file close degree for link\n"));
//open master file //open master file
hid_t mfd = H5Fopen( masterFileName.c_str(), H5F_ACC_RDWR, dfal); hid_t mfd = H5Fopen( masterFileName.c_str(), H5F_ACC_RDWR, dfal);
if (mfd < 0) if (mfd < 0)
return CloseFileOnError( vfd, std::string("Error in opening master file\n")); return CloseFileOnError( vfd, std::string("Could not open master file\n"));
//open virtual file //open virtual file
vfd = H5Fopen( virtualfname.c_str(), H5F_ACC_RDWR, dfal); vfd = H5Fopen( virtualfname.c_str(), H5F_ACC_RDWR, dfal);
if (vfd < 0) { if (vfd < 0) {
H5Fclose(mfd); mfd = 0; H5Fclose(mfd); mfd = 0;
return CloseFileOnError( vfd, std::string("Error in opening virtual file\n")); return CloseFileOnError( vfd, std::string("Could not open virtual file\n"));
} }
// find relative path // find relative path
@ -918,13 +918,13 @@ public:
hid_t vdset = H5Dopen2( vfd, virtualDatasetname.c_str(), H5P_DEFAULT); hid_t vdset = H5Dopen2( vfd, virtualDatasetname.c_str(), H5P_DEFAULT);
if (vdset < 0) { if (vdset < 0) {
H5Fclose(mfd); H5Fclose(mfd);
return CloseFileOnError( vfd, std::string("Error in opening virtual data dataset\n")); return CloseFileOnError( vfd, std::string("Could not open virtual data dataset\n"));
} }
sprintf(linkname, "/entry/data/%s",virtualDatasetname.c_str()); sprintf(linkname, "/entry/data/%s",virtualDatasetname.c_str());
if(H5Lcreate_external( relative_virtualfname.c_str(), virtualDatasetname.c_str(), if(H5Lcreate_external( relative_virtualfname.c_str(), virtualDatasetname.c_str(),
mfd, linkname, H5P_DEFAULT, H5P_DEFAULT) < 0) { mfd, linkname, H5P_DEFAULT, H5P_DEFAULT) < 0) {
H5Fclose(mfd); mfd = 0; H5Fclose(mfd); mfd = 0;
return CloseFileOnError( vfd, std::string("Error in creating link to data dataset\n")); return CloseFileOnError( vfd, std::string("Could not create link to data dataset\n"));
} }
H5Dclose(vdset); H5Dclose(vdset);
@ -933,14 +933,14 @@ public:
hid_t vdset_para = H5Dopen2( vfd, (std::string (parameterNames[i])).c_str(), H5P_DEFAULT); hid_t vdset_para = H5Dopen2( vfd, (std::string (parameterNames[i])).c_str(), H5P_DEFAULT);
if (vdset_para < 0) { if (vdset_para < 0) {
H5Fclose(mfd); mfd = 0; H5Fclose(mfd); mfd = 0;
return CloseFileOnError( vfd, std::string("Error in opening virtual parameter dataset to create link\n")); return CloseFileOnError( vfd, std::string("Could not open virtual parameter dataset to create link\n"));
} }
sprintf(linkname, "/entry/data/%s",(std::string (parameterNames[i])).c_str()); sprintf(linkname, "/entry/data/%s",(std::string (parameterNames[i])).c_str());
if(H5Lcreate_external( relative_virtualfname.c_str(), (std::string (parameterNames[i])).c_str(), if(H5Lcreate_external( relative_virtualfname.c_str(), (std::string (parameterNames[i])).c_str(),
mfd, linkname, H5P_DEFAULT, H5P_DEFAULT) < 0) { mfd, linkname, H5P_DEFAULT, H5P_DEFAULT) < 0) {
H5Fclose(mfd); mfd = 0; H5Fclose(mfd); mfd = 0;
return CloseFileOnError( vfd, std::string("Error in creating link to virtual parameter dataset\n")); return CloseFileOnError( vfd, std::string("Could not create link to virtual parameter dataset\n"));
} }
} }
@ -956,7 +956,7 @@ public:
* @returns 1 for fail * @returns 1 for fail
*/ */
static int CloseFileOnError(hid_t& fd, const std::string msg) { static int CloseFileOnError(hid_t& fd, const std::string msg) {
cprintf(RED, "%s", msg.c_str()); FILE_LOG(logERROR) << msg;
if(fd > 0) if(fd > 0)
H5Fclose(fd); H5Fclose(fd);
fd = 0; fd = 0;

3
slsReceiverSoftware/src/BinaryFile.cpp
View File

@ -106,8 +106,7 @@ int BinaryFile::WriteToFile(char* buffer, int buffersize, uint64_t fnum, uint32_
// if write error // if write error
if (ret != buffersize) { if (ret != buffersize) {
cprintf(RED,"%d Error: Write to file failed for image number %lld\n", FILE_LOG(logERROR) << index << " Error: Write to file failed for image number " << fnum;
index, (long long int)fnum);
return FAIL; return FAIL;
} }
return OK; return OK;

51
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -166,18 +166,14 @@ void DataProcessor::RecordFirstIndices(uint64_t fnum) {
firstAcquisitionIndex = fnum; firstAcquisitionIndex = fnum;
} }
#ifdef VERBOSE FILE_LOG(logDEBUG1) << index << " First Acquisition Index:" << firstAcquisitionIndex <<
cprintf(BLUE,"%d First Acquisition Index:%lld\tFirst Measurement Index:%lld\n", "\tFirst Measurement Index:" << firstMeasurementIndex;
index, (long long int)firstAcquisitionIndex, (long long int)firstMeasurementIndex);
#endif
} }
void DataProcessor::SetGeneralData(GeneralData* g) { void DataProcessor::SetGeneralData(GeneralData* g) {
generalData = g; generalData = g;
#ifdef VERY_VERBOSE
generalData->Print(); generalData->Print();
#endif
if (file) { if (file) {
if (file->GetFileType() == HDF5) { if (file->GetFileType() == HDF5) {
file->SetNumberofPixels(generalData->nPixelsX, generalData->nPixelsY); file->SetNumberofPixels(generalData->nPixelsX, generalData->nPixelsY);
@ -278,16 +274,12 @@ void DataProcessor::EndofAcquisition(bool anyPacketsCaught, uint64_t numf) {
void DataProcessor::ThreadExecution() { void DataProcessor::ThreadExecution() {
char* buffer=0; char* buffer=0;
fifo->PopAddress(buffer); fifo->PopAddress(buffer);
#ifdef FIFODEBUG FILE_LOG(logDEBUG5) << "DataProcessor " << index << ", "
if (!index) cprintf(BLUE,"DataProcessor %d, pop 0x%p buffer:%s\n", "pop 0x" << std::hex << (void*)(buffer) << std::dec << ":" << buffer;
index,(void*)(buffer),buffer);
#endif
//check dummy //check dummy
uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer)); uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer));
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "DataProcessor " << index << ", Numbytes:" << numBytes;
if (!index) cprintf(BLUE,"DataProcessor %d, Numbytes:%u\n", index,numBytes);
#endif
if (numBytes == DUMMY_PACKET_VALUE) { if (numBytes == DUMMY_PACKET_VALUE) {
StopProcessing(buffer); StopProcessing(buffer);
return; return;
@ -304,10 +296,8 @@ void DataProcessor::ThreadExecution() {
void DataProcessor::StopProcessing(char* buf) { void DataProcessor::StopProcessing(char* buf) {
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "DataProcessing " << index << ": Dummy";
if (!index)
cprintf(RED,"DataProcessing %d: Dummy\n", index);
#endif
//stream or free //stream or free
if (*dataStreamEnable) if (*dataStreamEnable)
fifo->PushAddressToStream(buf); fifo->PushAddressToStream(buf);
@ -317,9 +307,7 @@ void DataProcessor::StopProcessing(char* buf) {
if (file) if (file)
file->CloseCurrentFile(); file->CloseCurrentFile();
StopRunning(); StopRunning();
#ifdef VERBOSE FILE_LOG(logDEBUG1) << index << ": Processing Completed";
FILE_LOG(logINFO) << index << ": Processing Completed";
#endif
} }
@ -335,16 +323,9 @@ void DataProcessor::ProcessAnImage(char* buf) {
numTotalFramesCaught++; numTotalFramesCaught++;
} }
FILE_LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
#ifdef VERBOSE
if (!index)
cprintf(BLUE,"DataProcessing %d: fnum:%lu\n", index, fnum);
#endif
if (!measurementStartedFlag) { if (!measurementStartedFlag) {
#ifdef VERBOSE
if (!index) cprintf(BLUE,"DataProcessing %d: fnum:%lu\n", index, fnum);
#endif
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
if (*dataStreamEnable) { if (*dataStreamEnable) {
@ -418,11 +399,10 @@ bool DataProcessor::SendToStreamer() {
bool DataProcessor::CheckTimer() { bool DataProcessor::CheckTimer() {
struct timespec end; struct timespec end;
clock_gettime(CLOCK_REALTIME, &end); clock_gettime(CLOCK_REALTIME, &end);
#ifdef VERBOSE
cprintf(BLUE,"%d Timer elapsed time:%f seconds\n", index, FILE_LOG(logDEBUG1) << index << " Timer elapsed time:" <<
( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec ) (( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec ) / 1000000000.0)
/ 1000000000.0); << " seconds";
#endif
//still less than streaming timer, keep waiting //still less than streaming timer, keep waiting
if((( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec ) if((( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec )
/ 1000000000.0) < ((double)*streamingTimerInMs/1000.00)) / 1000000000.0) < ((double)*streamingTimerInMs/1000.00))
@ -464,9 +444,8 @@ void DataProcessor::PadMissingPackets(char* buf) {
uint32_t dsize = generalData->dataSize; uint32_t dsize = generalData->dataSize;
uint32_t fifohsize = generalData->fifoBufferHeaderSize; uint32_t fifohsize = generalData->fifoBufferHeaderSize;
uint32_t corrected_dsize = dsize - ((pperFrame * dsize) - generalData->imageSize); uint32_t corrected_dsize = dsize - ((pperFrame * dsize) - generalData->imageSize);
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "bitmask: " << pmask.to_string();
cprintf(RED,"bitmask:%s\n", pmask.to_string().c_str());
#endif
for (unsigned int pnum = 0; pnum < pperFrame; ++pnum) { for (unsigned int pnum = 0; pnum < pperFrame; ++pnum) {
// not missing packet // not missing packet

68
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -108,18 +108,14 @@ void DataStreamer::RecordFirstIndices(uint64_t fnum) {
firstAcquisitionIndex = fnum; firstAcquisitionIndex = fnum;
} }
#ifdef VERBOSE FILE_LOG(logDEBUG1) << index << " First Acquisition Index: " << firstAcquisitionIndex <<
cprintf(BLUE,"%d First Acquisition Index:%lld\tFirst Measurement Index:%lld\n", "\tFirst Measurement Index: " << firstMeasurementIndex;
index, (long long int)firstAcquisitionIndex, (long long int)firstMeasurementIndex);
#endif
} }
void DataStreamer::SetGeneralData(GeneralData* g) { void DataStreamer::SetGeneralData(GeneralData* g) {
generalData = g; generalData = g;
#ifdef VERY_VERBOSE
generalData->Print(); generalData->Print();
#endif
} }
int DataStreamer::SetThreadPriority(int priority) { int DataStreamer::SetThreadPriority(int priority) {
@ -138,7 +134,7 @@ void DataStreamer::CreateZmqSockets(int* nunits, uint32_t port, const char* srci
try { try {
zmqSocket = new ZmqSocket(portnum, (strlen(srcip)?srcip:NULL)); zmqSocket = new ZmqSocket(portnum, (strlen(srcip)?srcip:NULL));
} catch (...) { } catch (...) {
cprintf(RED, "Error: Could not create Zmq socket on port %d for Streamer %d\n", portnum, index); FILE_LOG(logERROR) << "Could not create Zmq socket on port " << portnum << " for Streamer " << index;
throw; throw;
} }
FILE_LOG(logINFO) << index << " Streamer: Zmq Server started at " << zmqSocket->GetZmqServerAddress(); FILE_LOG(logINFO) << index << " Streamer: Zmq Server started at " << zmqSocket->GetZmqServerAddress();
@ -156,15 +152,13 @@ void DataStreamer::CloseZmqSocket() {
void DataStreamer::ThreadExecution() { void DataStreamer::ThreadExecution() {
char* buffer=0; char* buffer=0;
fifo->PopAddressToStream(buffer); fifo->PopAddressToStream(buffer);
#ifdef FIFODEBUG FILE_LOG(logDEBUG5) << "DataStreamer " << index << ", "
if (!index) cprintf(BLUE,"DataStreamer %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer); "pop 0x" << std::hex << (void*)(buffer) << std::dec << ":" << buffer;
#endif
//check dummy //check dummy
uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer)); uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer));
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "DataStreamer " << index << ", Numbytes:" << numBytes;
cprintf(GREEN,"DataStreamer %d, Numbytes:%u\n", index,numBytes);
#endif
if (numBytes == DUMMY_PACKET_VALUE) { if (numBytes == DUMMY_PACKET_VALUE) {
StopProcessing(buffer); StopProcessing(buffer);
return; return;
@ -180,20 +174,17 @@ void DataStreamer::ThreadExecution() {
void DataStreamer::StopProcessing(char* buf) { void DataStreamer::StopProcessing(char* buf) {
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "DataStreamer " << index << ": Dummy";
if (!index)
cprintf(RED,"DataStreamer %d: Dummy\n", index);
#endif
sls_receiver_header* header = (sls_receiver_header*) (buf); sls_receiver_header* header = (sls_receiver_header*) (buf);
//send dummy header and data //send dummy header and data
if (!SendHeader(header, 0, 0, 0, true)) if (!SendHeader(header, 0, 0, 0, true)) {
cprintf(RED,"Error: Could not send zmq dummy header for streamer %d\n", index); FILE_LOG(logERROR) << "Could not send zmq dummy header for streamer " << index;
}
fifo->FreeAddress(buf); fifo->FreeAddress(buf);
StopRunning(); StopRunning();
#ifdef VERBOSE FILE_LOG(logDEBUG1) << index << ": Streaming Completed";
FILE_LOG(logINFO) << index << ": Streaming Completed";
#endif
} }
/** buf includes only the standard header */ /** buf includes only the standard header */
@ -201,14 +192,9 @@ void DataStreamer::ProcessAnImage(char* buf) {
sls_receiver_header* header = (sls_receiver_header*) (buf + FIFO_HEADER_NUMBYTES); sls_receiver_header* header = (sls_receiver_header*) (buf + FIFO_HEADER_NUMBYTES);
uint64_t fnum = header->detHeader.frameNumber; uint64_t fnum = header->detHeader.frameNumber;
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "DataStreamer " << index << ": fnum:" << fnum;
cprintf(MAGENTA,"DataStreamer %d: fnum:%lu\n", index,fnum);
#endif
if (!measurementStartedFlag) { if (!measurementStartedFlag) {
#ifdef VERBOSE
if (!index) cprintf(MAGENTA,"DataStreamer %d: fnum:%lu\n", index, fnum);
#endif
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
} }
@ -220,17 +206,16 @@ void DataStreamer::ProcessAnImage(char* buf) {
//write imagesize //write imagesize
if (!SendHeader(header, generalData->imageSizeComplete, if (!SendHeader(header, generalData->imageSizeComplete,
generalData->nPixelsXComplete, generalData->nPixelsYComplete, false)) generalData->nPixelsXComplete, generalData->nPixelsYComplete, false)) {
cprintf(RED,"Error: Could not send zmq header for fnum %lld and streamer %d\n", FILE_LOG(logERROR) << "Could not send zmq header for fnum " << fnum << " and streamer " << index;
(long long int) fnum, index); }
memcpy(completeBuffer + ((generalData->imageSize) * adcConfigured), memcpy(completeBuffer + ((generalData->imageSize) * adcConfigured),
buf + FIFO_HEADER_NUMBYTES + sizeof(sls_receiver_header), buf + FIFO_HEADER_NUMBYTES + sizeof(sls_receiver_header),
(uint32_t)(*((uint32_t*)buf)) ); (uint32_t)(*((uint32_t*)buf)) );
if (!zmqSocket->SendData(completeBuffer, generalData->imageSizeComplete)) if (!zmqSocket->SendData(completeBuffer, generalData->imageSizeComplete)) {
cprintf(RED,"Error: Could not send zmq data for fnum %lld and streamer %d\n", FILE_LOG(logERROR) << "Could not send zmq data for fnum " << fnum << " and streamer " << index;
(long long int) fnum, index); }
} }
@ -238,14 +223,13 @@ void DataStreamer::ProcessAnImage(char* buf) {
else { else {
if (!SendHeader(header, (uint32_t)(*((uint32_t*)buf)), if (!SendHeader(header, (uint32_t)(*((uint32_t*)buf)),
generalData->nPixelsX, generalData->nPixelsY, false)) // new size possibly from callback generalData->nPixelsX, generalData->nPixelsY, false)) {// new size possibly from callback
cprintf(RED,"Error: Could not send zmq header for fnum %lld and streamer %d\n", FILE_LOG(logERROR) << "Could not send zmq header for fnum " << fnum << " and streamer " << index;
(long long int) fnum, index); }
if (!zmqSocket->SendData(buf + FIFO_HEADER_NUMBYTES + sizeof(sls_receiver_header), if (!zmqSocket->SendData(buf + FIFO_HEADER_NUMBYTES + sizeof(sls_receiver_header),
(uint32_t)(*((uint32_t*)buf)) )) // new size possibly from callback (uint32_t)(*((uint32_t*)buf)) )) {// new size possibly from callback
cprintf(RED,"Error: Could not send zmq data for fnum %lld and streamer %d\n", FILE_LOG(logERROR) << "Could not send zmq data for fnum " << fnum << " and streamer " << index;
(long long int) fnum, index); }
} }
} }

9
slsReceiverSoftware/src/Fifo.cpp
View File

@ -21,22 +21,21 @@ Fifo::Fifo(int ind, uint32_t fifoItemSize, uint32_t depth):
fifoDepth(depth), fifoDepth(depth),
status_fifoBound(0), status_fifoBound(0),
status_fifoFree(depth){ status_fifoFree(depth){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(CreateFifos(fifoItemSize) == FAIL) if(CreateFifos(fifoItemSize) == FAIL)
throw std::exception(); throw std::exception();
} }
Fifo::~Fifo() { Fifo::~Fifo() {
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
//cprintf(BLUE,"Fifo Object %d: Goodbye\n", index);
DestroyFifos(); DestroyFifos();
} }
int Fifo::CreateFifos(uint32_t fifoItemSize) { int Fifo::CreateFifos(uint32_t fifoItemSize) {
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
//destroy if not already //destroy if not already
DestroyFifos(); DestroyFifos();
@ -69,7 +68,7 @@ int Fifo::CreateFifos(uint32_t fifoItemSize) {
void Fifo::DestroyFifos(){ void Fifo::DestroyFifos(){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(memory) { if(memory) {
free(memory); free(memory);

4
slsReceiverSoftware/src/File.cpp
View File

@ -38,8 +38,8 @@ std::string File::GetCurrentFileName() {
return currentFileName; return currentFileName;
} }
void File::PrintMembers() { void File::PrintMembers(TLogLevel level) {
FILE_LOG(logINFO) << "\nGeneral Writer Variables:" << std::endl FILE_LOG(level) << "\nGeneral Writer Variables:" << std::endl
<< "Index: " << index << std::endl << "Index: " << index << std::endl
<< "Max Frames Per File: " << *maxFramesPerFile << std::endl << "Max Frames Per File: " << *maxFramesPerFile << std::endl
<< "Number of Detectors in x dir: " << numDetX << std::endl << "Number of Detectors in x dir: " << numDetX << std::endl

19
slsReceiverSoftware/src/HDF5File.cpp
View File

@ -38,9 +38,7 @@ HDF5File::HDF5File(int ind, uint32_t* maxf,
dataspace_para(0), dataspace_para(0),
extNumImages(0) extNumImages(0)
{ {
#ifdef VERBOSE
PrintMembers(); PrintMembers();
#endif
dataset_para.clear(); dataset_para.clear();
parameterNames.clear(); parameterNames.clear();
parameterDataTypes.clear(); parameterDataTypes.clear();
@ -95,15 +93,15 @@ HDF5File::~HDF5File() {
CloseAllFiles(); CloseAllFiles();
} }
void HDF5File::PrintMembers() { void HDF5File::PrintMembers(TLogLevel level) {
File::PrintMembers(); File::PrintMembers();
UpdateDataType(); UpdateDataType();
if (datatype == PredType::STD_U8LE) { if (datatype == PredType::STD_U8LE) {
FILE_LOG(logINFO) << "Data Type: 4 or 8"; FILE_LOG(level) << "Data Type: 4 or 8";
} else if (datatype == PredType::STD_U16LE) { } else if (datatype == PredType::STD_U16LE) {
FILE_LOG(logINFO) << "Data Type: 16"; FILE_LOG(level) << "Data Type: 16";
} else if (datatype == PredType::STD_U32LE) { } else if (datatype == PredType::STD_U32LE) {
FILE_LOG(logINFO) << "Data Type: 32"; FILE_LOG(level) << "Data Type: 32";
} else { } else {
FILE_LOG(logERROR) << "unknown data type"; FILE_LOG(logERROR) << "unknown data type";
} }
@ -154,8 +152,6 @@ int HDF5File::CreateFile(uint64_t fnum) {
return FAIL; return FAIL;
} }
pthread_mutex_unlock(&Mutex); pthread_mutex_unlock(&Mutex);
if (dataspace == NULL)
cprintf(RED,"Got nothing!\n");
if(!(*silentMode)) { if(!(*silentMode)) {
FILE_LOG(logINFO) << *udpPortNumber << ": HDF5 File created: " << currentFileName; FILE_LOG(logINFO) << *udpPortNumber << ": HDF5 File created: " << currentFileName;
@ -214,9 +210,8 @@ int HDF5File::WriteToFile(char* buffer, int buffersize, uint64_t fnum, uint32_t
if (HDF5FileStatic::ExtendDataset(index, dataspace, dataset, if (HDF5FileStatic::ExtendDataset(index, dataspace, dataset,
dataspace_para, dataset_para, *numImages) == OK) { dataspace_para, dataset_para, *numImages) == OK) {
if (!(*silentMode)) { if (!(*silentMode)) {
cprintf(BLUE,"%d Extending HDF5 dataset by %llu, Total x Dimension: %llu\n", FILE_LOG(logINFO) << index << " Extending HDF5 dataset by " <<
index, (long long unsigned int)extNumImages, extNumImages << ", Total x Dimension: " << (extNumImages + *numImages);
(long long unsigned int)(extNumImages + *numImages));
} }
extNumImages += *numImages; extNumImages += *numImages;
} }
@ -238,7 +233,7 @@ int HDF5File::WriteToFile(char* buffer, int buffersize, uint64_t fnum, uint32_t
} }
} }
pthread_mutex_unlock(&Mutex); pthread_mutex_unlock(&Mutex);
cprintf(RED,"%d Error: Write to file failed\n", index); FILE_LOG(logERROR) << index << "Write to file failed";
return FAIL; return FAIL;
} }

56
slsReceiverSoftware/src/Listener.cpp
View File

@ -159,19 +159,18 @@ void Listener::RecordFirstIndices(uint64_t fnum) {
} }
if(!(*silentMode)) { if(!(*silentMode)) {
if (!index) cprintf(BLUE,"%d First Acquisition Index:%lu\n" if (!index) {
"%d First Measurement Index:%lu\n", FILE_LOG(logINFOBLUE) << index <<
index, firstAcquisitionIndex, " First Acquisition Index: " << firstAcquisitionIndex;
index, firstMeasurementIndex); FILE_LOG(logDEBUG1) << index << " First Measurement Index: " << firstMeasurementIndex;
}
} }
} }
void Listener::SetGeneralData(GeneralData*& g) { void Listener::SetGeneralData(GeneralData*& g) {
generalData = g; generalData = g;
#ifdef VERY_VERBOSE
generalData->Print(); generalData->Print();
#endif
} }
@ -300,9 +299,8 @@ void Listener::ThreadExecution() {
int rc = 0; int rc = 0;
fifo->GetNewAddress(buffer); fifo->GetNewAddress(buffer);
#ifdef FIFODEBUG FILE_LOG(logDEBUG5) << "Listener " << index << ", "
cprintf(GREEN,"Listener %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer); "pop 0x" << std::hex << (void*)(buffer) << std::dec << ":" << buffer;
#endif
//udpsocket doesnt exist //udpsocket doesnt exist
if (*activated && !udpSocketAlive && !carryOverFlag) { if (*activated && !udpSocketAlive && !carryOverFlag) {
@ -320,7 +318,6 @@ void Listener::ThreadExecution() {
//error check, (should not be here) if not transmitting yet (previous if) rc should be > 0 //error check, (should not be here) if not transmitting yet (previous if) rc should be > 0
if (rc == 0) { if (rc == 0) {
//cprintf(RED,"%d Socket shut down while waiting for future packet. udpsocketalive:%d\n",index, udpSocketAlive );
if (!udpSocketAlive) { if (!udpSocketAlive) {
(*((uint32_t*)buffer)) = 0; (*((uint32_t*)buffer)) = 0;
StopListening(buffer); StopListening(buffer);
@ -362,10 +359,8 @@ void Listener::StopListening(char* buf) {
StopRunning(); StopRunning();
sem_post(&semaphore_socket); sem_post(&semaphore_socket);
#ifdef VERBOSE FILE_LOG(logDEBUG1) << index << ": Listening Packets (" << *udpPortNumber << ") : " << numPacketsCaught;
cprintf(GREEN,"%d: Listening Packets (%u) : %llu\n", index, *udpPortNumber, numPacketsCaught); FILE_LOG(logDEBUG1) << index << ": Listening Completed";
cprintf(GREEN,"%d: Listening Completed\n", index);
#endif
} }
@ -418,7 +413,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//look for carry over //look for carry over
if (carryOverFlag) { if (carryOverFlag) {
//cprintf(RED,"%d carry flag\n",index); FILE_LOG(logDEBUG3) << index << "carry flag";
//check if its the current image packet //check if its the current image packet
// -------------------------- new header ---------------------------------------------------------------------- // -------------------------- new header ----------------------------------------------------------------------
if (standardheader) { if (standardheader) {
@ -434,7 +429,8 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------
if (fnum != currentFrameIndex) { if (fnum != currentFrameIndex) {
if (fnum < currentFrameIndex) { if (fnum < currentFrameIndex) {
cprintf(RED,"Error:(Weird), With carry flag: Frame number %lu less than current frame number %lu\n", fnum, currentFrameIndex); FILE_LOG(logERROR) << "(Weird), With carry flag: Frame number " <<
fnum << " less than current frame number " << currentFrameIndex;
return 0; return 0;
} }
switch(*frameDiscardMode) { switch(*frameDiscardMode) {
@ -551,25 +547,22 @@ uint32_t Listener::ListenToAnImage(char* buf) {
// Eiger Firmware in a weird state // Eiger Firmware in a weird state
if (myDetectorType == EIGER && fnum == 0) { if (myDetectorType == EIGER && fnum == 0) {
cprintf(RED,"[%u]: Got Frame Number Zero from Firmware. Discarding Packet\n", *udpPortNumber); FILE_LOG(logERROR) << "[" << *udpPortNumber << "]: Got Frame Number "
"Zero from Firmware. Discarding Packet";
numPacketsCaught--; numPacketsCaught--;
return 0; return 0;
} }
lastCaughtFrameIndex = fnum; lastCaughtFrameIndex = fnum;
FILE_LOG(logDEBUG5) << "Listening " << index << ": currentfindex:" << currentFrameIndex <<
", fnum:" << fnum << ", pnum:" << pnum << ", numpackets:" << numpackets;
#ifdef VERBOSE
//if (!index)
cprintf(GREEN,"Listening %d: currentfindex:%lu, fnum:%lu, pnum:%u numpackets:%u\n",
index,currentFrameIndex, fnum, pnum, numpackets);
#endif
if (!measurementStartedFlag) if (!measurementStartedFlag)
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
//future packet by looking at image number (all other detectors) //future packet by looking at image number (all other detectors)
if (fnum != currentFrameIndex) { if (fnum != currentFrameIndex) {
//cprintf(RED,"setting carry over flag to true num:%llu nump:%u\n",fnum, numpackets );
carryOverFlag = true; carryOverFlag = true;
memcpy(carryOverPacket,listeningPacket, generalData->packetSize); memcpy(carryOverPacket,listeningPacket, generalData->packetSize);
@ -641,19 +634,18 @@ uint32_t Listener::ListenToAnImage(char* buf) {
void Listener::PrintFifoStatistics() { void Listener::PrintFifoStatistics() {
#ifdef VERBOSE FILE_LOG(logDEBUG1) << "numFramesStatistic:" << numFramesStatistic << " numPacketsStatistic:" << numPacketsStatistic;
cout << "numFramesStatistic:" << numFramesStatistic << " numPacketsStatistic:" << numPacketsStatistic << endl;
#endif
//calculate packet loss //calculate packet loss
int64_t loss = -1; int64_t loss = -1;
loss = (numFramesStatistic*(generalData->packetsPerFrame)) - numPacketsStatistic; loss = (numFramesStatistic*(generalData->packetsPerFrame)) - numPacketsStatistic;
numPacketsStatistic = 0; numPacketsStatistic = 0;
numFramesStatistic = 0; numFramesStatistic = 0;
if (loss) FILE_LOG(loss ? logINFORED : logINFOGREEN) << "[" << *udpPortNumber << "]: "
cprintf(RED,"[%u]: Packet_Loss:%lu Used_Fifo_Max_Level:%d \tFree_Slots_Min_Level:%d \tCurrent_Frame#:%lu\n", "Packet_Loss:" << loss <<
*udpPortNumber,loss, fifo->GetMaxLevelForFifoBound() , fifo->GetMinLevelForFifoFree(), currentFrameIndex); " Used_Fifo_Max_Level:" << fifo->GetMaxLevelForFifoBound() <<
else " \tFree_Slots_Min_Level:" << fifo->GetMinLevelForFifoFree() <<
cprintf(GREEN,"[%u]: Packet_Loss:%lu Used_Fifo_Max_Level:%d \tFree_Slots_Min_Level:%d \tCurrent_Frame#:%lu\n", " \tCurrent_Frame#:" << currentFrameIndex;
*udpPortNumber,loss, fifo->GetMaxLevelForFifoBound(), fifo->GetMinLevelForFifoFree(), currentFrameIndex);
} }

6
slsReceiverSoftware/src/ThreadObject.cpp
View File

@ -74,7 +74,8 @@ void* ThreadObject::StartThread(void* thisPointer) {
void ThreadObject::RunningThread() { void ThreadObject::RunningThread() {
cprintf(BLUE,"Created [ %s Thread %d, Tid: %ld ]\n", GetType().c_str(),index, (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Created [ " << GetType() << "Thread " << index << ", "
"Tid: " << syscall(SYS_gettid) << "]";
while(true) { while(true) {
while(IsRunning()) { while(IsRunning()) {
@ -88,7 +89,8 @@ void ThreadObject::RunningThread() {
sem_wait(&semaphore); sem_wait(&semaphore);
if(killThread) { if(killThread) {
cprintf(BLUE,"Exiting [ %s Thread %d, Tid: %ld ]\n", GetType().c_str(),index, (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Exiting [ " << GetType() <<
" Thread " << index << ", Tid: " << syscall(SYS_gettid) << "]";
pthread_exit(NULL); pthread_exit(NULL);
} }

43
slsReceiverSoftware/src/main.cpp
View File

@ -24,18 +24,21 @@ void sigInterruptHandler(int p){
keeprunning = false; keeprunning = false;
} }
/** Define Colors to print data call back in different colors for different recievers */
/* /*
int StartAcq(char* filepath, char* filename, uint64_t fileindex, uint32_t datasize, void*p){ #define PRINT_IN_COLOR(c,f, ...) printf ("\033[%dm" f RESET, 30 + c+1, ##__VA_ARGS__)
printf("#### StartAcq: filepath:%s filename:%s fileindex:%llu datasize:%u ####\n",
filepath, filename, fileindex, datasize);
cprintf(BLUE, "--StartAcq: returning 0\n"); int StartAcq(char* filepath, char* filename, uint64_t fileindex, uint32_t datasize, void*p){
FILE_LOG(logINFO) << "#### StartAcq: "
"filepath: " << filepath << "filename: " << filename <<
"fileindex: " << fileindex << "datasize: " << datasize << " ####";
FILE_LOG(logINFO) << "--StartAcq: returning 0";
return 0; return 0;
} }
void AcquisitionFinished(uint64_t frames, void*p){ void AcquisitionFinished(uint64_t frames, void*p){
cprintf(BLUE, "#### AcquisitionFinished: frames:%llu ####\n",frames); FILE_LOG(logINFO) << "#### AcquisitionFinished: frames:" << frames << " ####";
} }
@ -45,16 +48,16 @@ void GetData(char* metadata, char* datapointer, uint32_t datasize, void* p){
PRINT_IN_COLOR (detectorHeader.modId?detectorHeader.modId:detectorHeader.row, PRINT_IN_COLOR (detectorHeader.modId?detectorHeader.modId:detectorHeader.row,
"#### %d GetData: ####\n" "#### %d GetData: ####\n"
"frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu" "frameNumber: %lu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %lu"
"\t\ttimestamp: %llu\t\tmodId: %u\t\t" "\t\ttimestamp: %lu\t\tmodId: %u\t\t"
"xCrow%u\t\tcolumn: %u\t\tcolumn: %u\t\tdebug: %u" "row: %u\t\tcolumn: %u\t\treserved: %u\t\tdebug: %u"
"\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u" "\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u"
//"\t\tpacketsMask:%s" //"\t\tpacketsMask:%s"
"\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n", "\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
detectorHeader.row, detectorHeader.frameNumber, detectorHeader.row, (long unsigned int)detectorHeader.frameNumber,
detectorHeader.expLength, detectorHeader.packetNumber, detectorHeader.bunchId, detectorHeader.expLength, detectorHeader.packetNumber, (long unsigned int)detectorHeader.bunchId,
detectorHeader.timestamp, detectorHeader.modId, (long unsigned int)detectorHeader.timestamp, detectorHeader.modId,
detectorHeader.row, detectorHeader.column, detectorHeader.column, detectorHeader.row, detectorHeader.column, detectorHeader.reserved,
detectorHeader.debug, detectorHeader.roundRNumber, detectorHeader.debug, detectorHeader.roundRNumber,
detectorHeader.detType, detectorHeader.version, detectorHeader.detType, detectorHeader.version,
//header->packetsMask.to_string().c_str(), //header->packetsMask.to_string().c_str(),
@ -66,7 +69,7 @@ void GetData(char* metadata, char* datapointer, uint32_t datasize, void* p){
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
keeprunning = true; keeprunning = true;
cprintf(BLUE,"Created [ Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Created [ Tid: " << syscall(SYS_gettid) << " ]";
// Catch signal SIGINT to close files and call destructors properly // Catch signal SIGINT to close files and call destructors properly
struct sigaction sa; struct sigaction sa;
@ -74,7 +77,7 @@ int main(int argc, char *argv[]) {
sa.sa_handler=sigInterruptHandler; // handler function sa.sa_handler=sigInterruptHandler; // handler function
sigemptyset(&sa.sa_mask); // dont block additional signals during invocation of handler sigemptyset(&sa.sa_mask); // dont block additional signals during invocation of handler
if (sigaction(SIGINT, &sa, NULL) == -1) { if (sigaction(SIGINT, &sa, NULL) == -1) {
cprintf(RED, "Could not set handler function for SIGINT\n"); FILE_LOG(logERROR) << "Could not set handler function for SIGINT";
} }
@ -85,7 +88,7 @@ int main(int argc, char *argv[]) {
asa.sa_handler=SIG_IGN; // handler function asa.sa_handler=SIG_IGN; // handler function
sigemptyset(&asa.sa_mask); // dont block additional signals during invocation of handler sigemptyset(&asa.sa_mask); // dont block additional signals during invocation of handler
if (sigaction(SIGPIPE, &asa, NULL) == -1) { if (sigaction(SIGPIPE, &asa, NULL) == -1) {
cprintf(RED, "Could not set handler function for SIGPIPE\n"); FILE_LOG(logERROR) << "Could not set handler function for SIGPIPE";
} }
@ -93,7 +96,7 @@ int main(int argc, char *argv[]) {
slsReceiverUsers *receiver = new slsReceiverUsers(argc, argv, ret); slsReceiverUsers *receiver = new slsReceiverUsers(argc, argv, ret);
if(ret==slsDetectorDefs::FAIL){ if(ret==slsDetectorDefs::FAIL){
delete receiver; delete receiver;
cprintf(BLUE,"Exiting [ Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Exiting [ Tid: " << syscall(SYS_gettid) << " ]";
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
@ -142,18 +145,18 @@ int main(int argc, char *argv[]) {
//start tcp server thread //start tcp server thread
if (receiver->start() == slsDetectorDefs::FAIL){ if (receiver->start() == slsDetectorDefs::FAIL){
delete receiver; delete receiver;
cprintf(BLUE,"Exiting [ Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Exiting [ Tid: " << syscall(SYS_gettid) << " ]";
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
FILE_LOG(logINFO) << "Ready ... "; FILE_LOG(logINFO) << "Ready ... ";
cprintf(RESET, "\n[ Press \'Ctrl+c\' to exit ]\n"); FILE_LOG(logINFO) << "[ Press \'Ctrl+c\' to exit ]";
while(keeprunning) while(keeprunning)
pause(); pause();
delete receiver; delete receiver;
cprintf(BLUE,"Exiting [ Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Exiting [ Tid: " << syscall(SYS_gettid) << " ]";
FILE_LOG(logINFO) << "Goodbye!"; FILE_LOG(logINFO) << "Exiting Receiver";
return 0; return 0;
} }

428
slsReceiverSoftware/src/slsReceiverImplementation.cpp
View File

@ -24,16 +24,19 @@
/** cosntructor & destructor */ /** cosntructor & destructor */
slsReceiverImplementation::slsReceiverImplementation() { slsReceiverImplementation::slsReceiverImplementation() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
InitializeMembers(); InitializeMembers();
} }
slsReceiverImplementation::~slsReceiverImplementation() { slsReceiverImplementation::~slsReceiverImplementation() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
DeleteMembers(); DeleteMembers();
} }
void slsReceiverImplementation::DeleteMembers() { void slsReceiverImplementation::DeleteMembers() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (generalData) { if (generalData) {
delete generalData; delete generalData;
generalData=0; generalData=0;
@ -58,7 +61,7 @@ void slsReceiverImplementation::DeleteMembers() {
void slsReceiverImplementation::InitializeMembers() { void slsReceiverImplementation::InitializeMembers() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
//**detector parameters*** //**detector parameters***
myDetectorType = GENERIC; myDetectorType = GENERIC;
for (int i = 0; i < MAX_DIMENSIONS; ++i) for (int i = 0; i < MAX_DIMENSIONS; ++i)
@ -113,7 +116,7 @@ void slsReceiverImplementation::InitializeMembers() {
dataStreamEnable = false; dataStreamEnable = false;
streamingPort = 0; streamingPort = 0;
memset(streamingSrcIP, 0, sizeof(streamingSrcIP)); memset(streamingSrcIP, 0, sizeof(streamingSrcIP));
memset(additionalJsonHeader, 0, sizeof(additionalJsonHeader)); memset(additionalJsonHeader, 0, sizeof(additionalJsonHeader));
//** class objects *** //** class objects ***
generalData = 0; generalData = 0;
@ -135,77 +138,77 @@ void slsReceiverImplementation::InitializeMembers() {
/**initial parameters***/ /**initial parameters***/
int* slsReceiverImplementation::getMultiDetectorSize() const{ int* slsReceiverImplementation::getMultiDetectorSize() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return (int*) numDet; return (int*) numDet;
} }
int slsReceiverImplementation::getDetectorPositionId() const{ int slsReceiverImplementation::getDetectorPositionId() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return detID; return detID;
} }
std::string slsReceiverImplementation::getDetectorHostname() const{ std::string slsReceiverImplementation::getDetectorHostname() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return std::string(detHostname); return std::string(detHostname);
} }
int slsReceiverImplementation::getFlippedData(int axis) const{ int slsReceiverImplementation::getFlippedData(int axis) const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(axis<0 || axis > 1) return -1; if(axis<0 || axis > 1) return -1;
return flippedData[axis]; return flippedData[axis];
} }
bool slsReceiverImplementation::getGapPixelsEnable() const { bool slsReceiverImplementation::getGapPixelsEnable() const {
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return gapPixelsEnable; return gapPixelsEnable;
} }
/***file parameters***/ /***file parameters***/
slsDetectorDefs::fileFormat slsReceiverImplementation::getFileFormat() const{ slsDetectorDefs::fileFormat slsReceiverImplementation::getFileFormat() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileFormatType; return fileFormatType;
} }
std::string slsReceiverImplementation::getFileName() const{ std::string slsReceiverImplementation::getFileName() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return std::string(fileName); return std::string(fileName);
} }
std::string slsReceiverImplementation::getFilePath() const{ std::string slsReceiverImplementation::getFilePath() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return std::string(filePath); return std::string(filePath);
} }
uint64_t slsReceiverImplementation::getFileIndex() const{ uint64_t slsReceiverImplementation::getFileIndex() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileIndex; return fileIndex;
} }
uint32_t slsReceiverImplementation::getFramesPerFile() const{ uint32_t slsReceiverImplementation::getFramesPerFile() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return framesPerFile; return framesPerFile;
} }
slsDetectorDefs::frameDiscardPolicy slsReceiverImplementation::getFrameDiscardPolicy() const{ slsDetectorDefs::frameDiscardPolicy slsReceiverImplementation::getFrameDiscardPolicy() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return frameDiscardMode; return frameDiscardMode;
} }
bool slsReceiverImplementation::getFramePaddingEnable() const{ bool slsReceiverImplementation::getFramePaddingEnable() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return framePadding; return framePadding;
} }
bool slsReceiverImplementation::getFileWriteEnable() const{ bool slsReceiverImplementation::getFileWriteEnable() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileWriteEnable; return fileWriteEnable;
} }
bool slsReceiverImplementation::getOverwriteEnable() const{ bool slsReceiverImplementation::getOverwriteEnable() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return overwriteEnable; return overwriteEnable;
} }
@ -261,130 +264,130 @@ int64_t slsReceiverImplementation::getAcquisitionIndex() const {
/***connection parameters***/ /***connection parameters***/
uint32_t slsReceiverImplementation::getUDPPortNumber() const{ uint32_t slsReceiverImplementation::getUDPPortNumber() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return udpPortNum[0]; return udpPortNum[0];
} }
uint32_t slsReceiverImplementation::getUDPPortNumber2() const{ uint32_t slsReceiverImplementation::getUDPPortNumber2() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return udpPortNum[1]; return udpPortNum[1];
} }
std::string slsReceiverImplementation::getEthernetInterface() const{ std::string slsReceiverImplementation::getEthernetInterface() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return std::string(eth); return std::string(eth);
} }
/***acquisition parameters***/ /***acquisition parameters***/
std::vector<slsDetectorDefs::ROI> slsReceiverImplementation::getROI() const{ std::vector<slsDetectorDefs::ROI> slsReceiverImplementation::getROI() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return roi; return roi;
} }
uint32_t slsReceiverImplementation::getStreamingFrequency() const{ uint32_t slsReceiverImplementation::getStreamingFrequency() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingFrequency; return streamingFrequency;
} }
uint32_t slsReceiverImplementation::getStreamingTimer() const{ uint32_t slsReceiverImplementation::getStreamingTimer() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingTimerInMs; return streamingTimerInMs;
} }
bool slsReceiverImplementation::getDataStreamEnable() const{ bool slsReceiverImplementation::getDataStreamEnable() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return dataStreamEnable; return dataStreamEnable;
} }
uint64_t slsReceiverImplementation::getAcquisitionPeriod() const{ uint64_t slsReceiverImplementation::getAcquisitionPeriod() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return acquisitionPeriod; return acquisitionPeriod;
} }
uint64_t slsReceiverImplementation::getAcquisitionTime() const{ uint64_t slsReceiverImplementation::getAcquisitionTime() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return acquisitionTime; return acquisitionTime;
} }
uint64_t slsReceiverImplementation::getSubExpTime() const{ uint64_t slsReceiverImplementation::getSubExpTime() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return subExpTime; return subExpTime;
} }
uint64_t slsReceiverImplementation::getSubPeriod() const{ uint64_t slsReceiverImplementation::getSubPeriod() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return subPeriod; return subPeriod;
} }
uint64_t slsReceiverImplementation::getNumberOfFrames() const{ uint64_t slsReceiverImplementation::getNumberOfFrames() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numberOfFrames; return numberOfFrames;
} }
uint64_t slsReceiverImplementation::getNumberofSamples() const{ uint64_t slsReceiverImplementation::getNumberofSamples() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numberOfSamples; return numberOfSamples;
} }
uint32_t slsReceiverImplementation::getDynamicRange() const{ uint32_t slsReceiverImplementation::getDynamicRange() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return dynamicRange;} return dynamicRange;}
bool slsReceiverImplementation::getTenGigaEnable() const{ bool slsReceiverImplementation::getTenGigaEnable() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return tengigaEnable; return tengigaEnable;
} }
uint32_t slsReceiverImplementation::getFifoDepth() const{ uint32_t slsReceiverImplementation::getFifoDepth() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fifoDepth; return fifoDepth;
} }
/***receiver status***/ /***receiver status***/
slsDetectorDefs::runStatus slsReceiverImplementation::getStatus() const{ slsDetectorDefs::runStatus slsReceiverImplementation::getStatus() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return status; return status;
} }
bool slsReceiverImplementation::getSilentMode() const{ bool slsReceiverImplementation::getSilentMode() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return silentMode; return silentMode;
} }
bool slsReceiverImplementation::getActivate() const{ bool slsReceiverImplementation::getActivate() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return activated; return activated;
} }
bool slsReceiverImplementation::getDeactivatedPadding() const{ bool slsReceiverImplementation::getDeactivatedPadding() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return deactivatedPaddingEnable; return deactivatedPaddingEnable;
} }
uint32_t slsReceiverImplementation::getStreamingPort() const{ uint32_t slsReceiverImplementation::getStreamingPort() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingPort; return streamingPort;
} }
std::string slsReceiverImplementation::getStreamingSourceIP() const{ std::string slsReceiverImplementation::getStreamingSourceIP() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return std::string(streamingSrcIP); return std::string(streamingSrcIP);
} }
std::string slsReceiverImplementation::getAdditionalJsonHeader() const{ std::string slsReceiverImplementation::getAdditionalJsonHeader() const{
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return std::string(additionalJsonHeader); return std::string(additionalJsonHeader);
} }
uint32_t slsReceiverImplementation::getUDPSocketBufferSize() const { uint32_t slsReceiverImplementation::getUDPSocketBufferSize() const {
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return udpSocketBufferSize; return udpSocketBufferSize;
} }
uint32_t slsReceiverImplementation::getActualUDPSocketBufferSize() const { uint32_t slsReceiverImplementation::getActualUDPSocketBufferSize() const {
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return actualUDPSocketBufferSize; return actualUDPSocketBufferSize;
} }
@ -396,7 +399,7 @@ uint32_t slsReceiverImplementation::getActualUDPSocketBufferSize() const {
/**initial parameters***/ /**initial parameters***/
void slsReceiverImplementation::setDetectorHostname(const char *c){ void slsReceiverImplementation::setDetectorHostname(const char *c){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(strlen(c)) if(strlen(c))
strcpy(detHostname, c); strcpy(detHostname, c);
@ -405,7 +408,7 @@ void slsReceiverImplementation::setDetectorHostname(const char *c){
void slsReceiverImplementation::setMultiDetectorSize(const int* size) { void slsReceiverImplementation::setMultiDetectorSize(const int* size) {
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
char message[100]; char message[100];
strcpy(message, "Detector Size: ("); strcpy(message, "Detector Size: (");
for (int i = 0; i < MAX_DIMENSIONS; ++i) { for (int i = 0; i < MAX_DIMENSIONS; ++i) {
@ -423,7 +426,7 @@ void slsReceiverImplementation::setMultiDetectorSize(const int* size) {
void slsReceiverImplementation::setFlippedData(int axis, int enable){ void slsReceiverImplementation::setFlippedData(int axis, int enable){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(axis<0 || axis>1) return; if(axis<0 || axis>1) return;
flippedData[axis] = enable==0?0:1; flippedData[axis] = enable==0?0:1;
FILE_LOG(logINFO) << "Flipped Data: " << flippedData[0] << " , " << flippedData[1]; FILE_LOG(logINFO) << "Flipped Data: " << flippedData[0] << " , " << flippedData[1];
@ -469,7 +472,7 @@ void slsReceiverImplementation::setFileFormat(const fileFormat f){
void slsReceiverImplementation::setFileName(const char c[]){ void slsReceiverImplementation::setFileName(const char c[]){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(strlen(c)) if(strlen(c))
strcpy(fileName, c); strcpy(fileName, c);
@ -478,7 +481,7 @@ void slsReceiverImplementation::setFileName(const char c[]){
void slsReceiverImplementation::setFilePath(const char c[]){ void slsReceiverImplementation::setFilePath(const char c[]){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(strlen(c)){ if(strlen(c)){
@ -494,7 +497,7 @@ void slsReceiverImplementation::setFilePath(const char c[]){
void slsReceiverImplementation::setFileIndex(const uint64_t i){ void slsReceiverImplementation::setFileIndex(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
fileIndex = i; fileIndex = i;
FILE_LOG(logINFO) << "File Index: " << fileIndex; FILE_LOG(logINFO) << "File Index: " << fileIndex;
@ -502,7 +505,7 @@ void slsReceiverImplementation::setFileIndex(const uint64_t i){
void slsReceiverImplementation::setFramesPerFile(const uint32_t i){ void slsReceiverImplementation::setFramesPerFile(const uint32_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
framesPerFile = i; framesPerFile = i;
FILE_LOG(logINFO) << "Frames per file: " << framesPerFile; FILE_LOG(logINFO) << "Frames per file: " << framesPerFile;
@ -510,7 +513,7 @@ void slsReceiverImplementation::setFramesPerFile(const uint32_t i){
void slsReceiverImplementation::setFrameDiscardPolicy(const frameDiscardPolicy i){ void slsReceiverImplementation::setFrameDiscardPolicy(const frameDiscardPolicy i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (i >= 0 && i < NUM_DISCARD_POLICIES) if (i >= 0 && i < NUM_DISCARD_POLICIES)
frameDiscardMode = i; frameDiscardMode = i;
@ -520,7 +523,7 @@ void slsReceiverImplementation::setFrameDiscardPolicy(const frameDiscardPolicy i
void slsReceiverImplementation::setFramePaddingEnable(const bool i){ void slsReceiverImplementation::setFramePaddingEnable(const bool i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
framePadding = i; framePadding = i;
FILE_LOG(logINFO) << "Frame Padding: " << framePadding; FILE_LOG(logINFO) << "Frame Padding: " << framePadding;
@ -531,7 +534,7 @@ void slsReceiverImplementation::setFileWriteEnable(const bool b){
if (fileWriteEnable != b){ if (fileWriteEnable != b){
fileWriteEnable = b; fileWriteEnable = b;
for (unsigned int i = 0; i < dataProcessor.size(); ++i) { for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
dataProcessor[i]->SetupFileWriter(fileWriteEnable, (int*)numDet, dataProcessor[i]->SetupFileWriter(fileWriteEnable, (int*)numDet,
&framesPerFile, fileName, filePath, &fileIndex, &overwriteEnable, &framesPerFile, fileName, filePath, &fileIndex, &overwriteEnable,
&detID, &numThreads, &numberOfFrames, &dynamicRange, &udpPortNum[i], &detID, &numThreads, &numberOfFrames, &dynamicRange, &udpPortNum[i],
generalData); generalData);
@ -543,7 +546,7 @@ void slsReceiverImplementation::setFileWriteEnable(const bool b){
void slsReceiverImplementation::setOverwriteEnable(const bool b){ void slsReceiverImplementation::setOverwriteEnable(const bool b){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
overwriteEnable = b; overwriteEnable = b;
FILE_LOG(logINFO) << "Overwrite Enable: " << stringEnable(overwriteEnable); FILE_LOG(logINFO) << "Overwrite Enable: " << stringEnable(overwriteEnable);
@ -552,37 +555,37 @@ void slsReceiverImplementation::setOverwriteEnable(const bool b){
/***connection parameters***/ /***connection parameters***/
void slsReceiverImplementation::setUDPPortNumber(const uint32_t i){ void slsReceiverImplementation::setUDPPortNumber(const uint32_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
udpPortNum[0] = i; udpPortNum[0] = i;
FILE_LOG(logINFO) << "UDP Port Number[0]: " << udpPortNum[0]; FILE_LOG(logINFO) << "UDP Port Number[0]: " << udpPortNum[0];
} }
void slsReceiverImplementation::setUDPPortNumber2(const uint32_t i){ void slsReceiverImplementation::setUDPPortNumber2(const uint32_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
udpPortNum[1] = i; udpPortNum[1] = i;
FILE_LOG(logINFO) << "UDP Port Number[1]: " << udpPortNum[1]; FILE_LOG(logINFO) << "UDP Port Number[1]: " << udpPortNum[1];
} }
void slsReceiverImplementation::setEthernetInterface(const char* c){ void slsReceiverImplementation::setEthernetInterface(const char* c){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
strcpy(eth, c); strcpy(eth, c);
FILE_LOG(logINFO) << "Ethernet Interface: " << eth; FILE_LOG(logINFO) << "Ethernet Interface: " << eth;
} }
int slsReceiverImplementation::setUDPSocketBufferSize(const uint32_t s) { int slsReceiverImplementation::setUDPSocketBufferSize(const uint32_t s) {
if (listener.size()) if (listener.size())
return listener[0]->CreateDummySocketForUDPSocketBufferSize(s); return listener[0]->CreateDummySocketForUDPSocketBufferSize(s);
return FAIL; return FAIL;
} }
/***acquisition parameters***/ /***acquisition parameters***/
int slsReceiverImplementation::setROI(const std::vector<slsDetectorDefs::ROI> i) { int slsReceiverImplementation::setROI(const std::vector<slsDetectorDefs::ROI> i) {
if (myDetectorType != GOTTHARD) { if (myDetectorType != GOTTHARD) {
cprintf(RED, "Error: Can not set ROI for this detector\n"); FILE_LOG(logERROR) << "Can not set ROI for this detector";
return FAIL; return FAIL;
} }
@ -651,7 +654,7 @@ int slsReceiverImplementation::setStreamingFrequency(const uint32_t freq) {
} }
void slsReceiverImplementation::setStreamingTimer(const uint32_t time_in_ms){ void slsReceiverImplementation::setStreamingTimer(const uint32_t time_in_ms){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
streamingTimerInMs = time_in_ms; streamingTimerInMs = time_in_ms;
FILE_LOG(logINFO) << "Streamer Timer: " << streamingTimerInMs; FILE_LOG(logINFO) << "Streamer Timer: " << streamingTimerInMs;
@ -669,23 +672,23 @@ int slsReceiverImplementation::setDataStreamEnable(const bool enable) {
dataStreamer.clear(); dataStreamer.clear();
if (enable) { if (enable) {
for ( int i = 0; i < numThreads; ++i ) { for ( int i = 0; i < numThreads; ++i ) {
try { try {
DataStreamer* s = new DataStreamer(i, fifo[i], &dynamicRange, DataStreamer* s = new DataStreamer(i, fifo[i], &dynamicRange,
&roi, &fileIndex, flippedData, additionalJsonHeader, &silentMode); &roi, &fileIndex, flippedData, additionalJsonHeader, &silentMode);
dataStreamer.push_back(s); dataStreamer.push_back(s);
dataStreamer[i]->SetGeneralData(generalData); dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(&numThreads, streamingPort, streamingSrcIP); dataStreamer[i]->CreateZmqSockets(&numThreads, streamingPort, streamingSrcIP);
} }
catch(...) { catch(...) {
for (std::vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it) for (std::vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it)
delete(*it); delete(*it);
dataStreamer.clear(); dataStreamer.clear();
dataStreamEnable = false; dataStreamEnable = false;
return FAIL; return FAIL;
} }
} }
SetThreadPriorities(); SetThreadPriorities();
} }
} }
FILE_LOG(logINFO) << "Data Send to Gui: " << dataStreamEnable; FILE_LOG(logINFO) << "Data Send to Gui: " << dataStreamEnable;
@ -701,21 +704,21 @@ void slsReceiverImplementation::setStreamingPort(const uint32_t i) {
void slsReceiverImplementation::setStreamingSourceIP(const char c[]){ void slsReceiverImplementation::setStreamingSourceIP(const char c[]){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
strcpy(streamingSrcIP, c); strcpy(streamingSrcIP, c);
FILE_LOG(logINFO) << "Streaming Source IP: " << streamingSrcIP; FILE_LOG(logINFO) << "Streaming Source IP: " << streamingSrcIP;
} }
void slsReceiverImplementation::setAdditionalJsonHeader(const char c[]){ void slsReceiverImplementation::setAdditionalJsonHeader(const char c[]){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
strcpy(additionalJsonHeader, c); strcpy(additionalJsonHeader, c);
FILE_LOG(logINFO) << "Additional JSON Header: " << additionalJsonHeader; FILE_LOG(logINFO) << "Additional JSON Header: " << additionalJsonHeader;
} }
int slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i){ int slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
acquisitionPeriod = i; acquisitionPeriod = i;
FILE_LOG(logINFO) << "Acquisition Period: " << (double)acquisitionPeriod/(1E9) << "s"; FILE_LOG(logINFO) << "Acquisition Period: " << (double)acquisitionPeriod/(1E9) << "s";
@ -725,7 +728,7 @@ int slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i){
} }
int slsReceiverImplementation::setAcquisitionTime(const uint64_t i){ int slsReceiverImplementation::setAcquisitionTime(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
acquisitionTime = i; acquisitionTime = i;
FILE_LOG(logINFO) << "Acquisition Time: " << (double)acquisitionTime/(1E9) << "s"; FILE_LOG(logINFO) << "Acquisition Time: " << (double)acquisitionTime/(1E9) << "s";
@ -735,21 +738,21 @@ int slsReceiverImplementation::setAcquisitionTime(const uint64_t i){
} }
void slsReceiverImplementation::setSubExpTime(const uint64_t i){ void slsReceiverImplementation::setSubExpTime(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
subExpTime = i; subExpTime = i;
FILE_LOG(logINFO) << "Sub Exposure Time: " << (double)subExpTime/(1E9) << "s"; FILE_LOG(logINFO) << "Sub Exposure Time: " << (double)subExpTime/(1E9) << "s";
} }
void slsReceiverImplementation::setSubPeriod(const uint64_t i){ void slsReceiverImplementation::setSubPeriod(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
subPeriod = i; subPeriod = i;
FILE_LOG(logINFO) << "Sub Exposure Period: " << (double)subPeriod/(1E9) << "s"; FILE_LOG(logINFO) << "Sub Exposure Period: " << (double)subPeriod/(1E9) << "s";
} }
int slsReceiverImplementation::setNumberOfFrames(const uint64_t i){ int slsReceiverImplementation::setNumberOfFrames(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
numberOfFrames = i; numberOfFrames = i;
FILE_LOG(logINFO) << "Number of Frames: " << numberOfFrames; FILE_LOG(logINFO) << "Number of Frames: " << numberOfFrames;
@ -824,7 +827,7 @@ int slsReceiverImplementation::setFifoDepth(const uint32_t i) {
/***receiver parameters***/ /***receiver parameters***/
bool slsReceiverImplementation::setActivate(bool enable){ bool slsReceiverImplementation::setActivate(bool enable){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
activated = enable; activated = enable;
FILE_LOG(logINFO) << "Activation: " << stringEnable(activated); FILE_LOG(logINFO) << "Activation: " << stringEnable(activated);
return activated; return activated;
@ -832,14 +835,14 @@ bool slsReceiverImplementation::setActivate(bool enable){
bool slsReceiverImplementation::setDeactivatedPadding(bool enable){ bool slsReceiverImplementation::setDeactivatedPadding(bool enable){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
deactivatedPaddingEnable = enable; deactivatedPaddingEnable = enable;
FILE_LOG(logINFO) << "Deactivated Padding Enable: " << stringEnable(deactivatedPaddingEnable); FILE_LOG(logINFO) << "Deactivated Padding Enable: " << stringEnable(deactivatedPaddingEnable);
return deactivatedPaddingEnable; return deactivatedPaddingEnable;
} }
void slsReceiverImplementation::setSilentMode(const bool i){ void slsReceiverImplementation::setSilentMode(const bool i){
FILE_LOG(logDEBUG) << __AT__ << " starting"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
silentMode = i; silentMode = i;
FILE_LOG(logINFO) << "Silent Mode: " << i; FILE_LOG(logINFO) << "Silent Mode: " << i;
@ -854,7 +857,7 @@ void slsReceiverImplementation::setSilentMode(const bool i){
/***initial functions***/ /***initial functions***/
int slsReceiverImplementation::setDetectorType(const detectorType d) { int slsReceiverImplementation::setDetectorType(const detectorType d) {
FILE_LOG(logDEBUG) << "Setting receiver type"; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
DeleteMembers(); DeleteMembers();
InitializeMembers(); InitializeMembers();
myDetectorType = d; myDetectorType = d;
@ -897,30 +900,30 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) {
//create threads //create threads
for ( int i = 0; i < numThreads; ++i ) { for ( int i = 0; i < numThreads; ++i ) {
try { try {
Listener* l = new Listener(i, myDetectorType, fifo[i], &status, Listener* l = new Listener(i, myDetectorType, fifo[i], &status,
&udpPortNum[i], eth, &numberOfFrames, &dynamicRange, &udpPortNum[i], eth, &numberOfFrames, &dynamicRange,
&udpSocketBufferSize, &actualUDPSocketBufferSize, &framesPerFile, &udpSocketBufferSize, &actualUDPSocketBufferSize, &framesPerFile,
&frameDiscardMode, &activated, &deactivatedPaddingEnable, &silentMode); &frameDiscardMode, &activated, &deactivatedPaddingEnable, &silentMode);
listener.push_back(l); listener.push_back(l);
DataProcessor* p = new DataProcessor(i, myDetectorType, fifo[i], &fileFormatType, DataProcessor* p = new DataProcessor(i, myDetectorType, fifo[i], &fileFormatType,
fileWriteEnable, &dataStreamEnable, &gapPixelsEnable, fileWriteEnable, &dataStreamEnable, &gapPixelsEnable,
&dynamicRange, &streamingFrequency, &streamingTimerInMs, &dynamicRange, &streamingFrequency, &streamingTimerInMs,
&framePadding, &activated, &deactivatedPaddingEnable, &silentMode, &framePadding, &activated, &deactivatedPaddingEnable, &silentMode,
rawDataReadyCallBack, rawDataModifyReadyCallBack, pRawDataReady); rawDataReadyCallBack, rawDataModifyReadyCallBack, pRawDataReady);
dataProcessor.push_back(p); dataProcessor.push_back(p);
} }
catch (...) { catch (...) {
FILE_LOG(logERROR) << "Could not create listener/dataprocessor threads (index:" << i << ")"; FILE_LOG(logERROR) << "Could not create listener/dataprocessor threads (index:" << i << ")";
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
delete(*it); delete(*it);
listener.clear(); listener.clear();
for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it)
delete(*it); delete(*it);
dataProcessor.clear(); dataProcessor.clear();
return FAIL; return FAIL;
} }
} }
//set up writer and callbacks //set up writer and callbacks
@ -931,8 +934,8 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) {
SetThreadPriorities(); SetThreadPriorities();
// check udp socket buffer size // check udp socket buffer size
setUDPSocketBufferSize(udpSocketBufferSize); setUDPSocketBufferSize(udpSocketBufferSize);
FILE_LOG(logDEBUG) << " Detector type set to " << getDetectorType(d); FILE_LOG(logDEBUG) << " Detector type set to " << getDetectorType(d);
return OK; return OK;
@ -942,6 +945,7 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) {
void slsReceiverImplementation::setDetectorPositionId(const int i){ void slsReceiverImplementation::setDetectorPositionId(const int i){
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
detID = i; detID = i;
FILE_LOG(logINFO) << "Detector Position Id:" << detID; FILE_LOG(logINFO) << "Detector Position Id:" << detID;
for (unsigned int i = 0; i < dataProcessor.size(); ++i) { for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
@ -962,6 +966,7 @@ void slsReceiverImplementation::setDetectorPositionId(const int i){
/***acquisition functions***/ /***acquisition functions***/
void slsReceiverImplementation::resetAcquisitionCount() { void slsReceiverImplementation::resetAcquisitionCount() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
(*it)->ResetParametersforNewAcquisition(); (*it)->ResetParametersforNewAcquisition();
@ -977,7 +982,7 @@ void slsReceiverImplementation::resetAcquisitionCount() {
int slsReceiverImplementation::startReceiver(char *c) { int slsReceiverImplementation::startReceiver(char *c) {
cprintf(RESET,"\n"); FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
FILE_LOG(logINFO) << "Starting Receiver"; FILE_LOG(logINFO) << "Starting Receiver";
ResetParametersforNewMeasurement(); ResetParametersforNewMeasurement();
@ -1023,6 +1028,7 @@ int slsReceiverImplementation::startReceiver(char *c) {
void slsReceiverImplementation::stopReceiver(){ void slsReceiverImplementation::stopReceiver(){
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
FILE_LOG(logINFO) << "Stopping Receiver"; FILE_LOG(logINFO) << "Stopping Receiver";
//set status to transmitting //set status to transmitting
@ -1031,14 +1037,14 @@ void slsReceiverImplementation::stopReceiver(){
//wait for the processes (Listener and DataProcessor) to be done //wait for the processes (Listener and DataProcessor) to be done
bool running = true; bool running = true;
while(running) { while(running) {
running = false; running = false;
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
if ((*it)->IsRunning()) if ((*it)->IsRunning())
running = true; running = true;
for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it)
if ((*it)->IsRunning()) if ((*it)->IsRunning())
running = true; running = true;
usleep(5000); usleep(5000);
} }
@ -1057,13 +1063,13 @@ void slsReceiverImplementation::stopReceiver(){
//wait for the processes (DataStreamer) to be done //wait for the processes (DataStreamer) to be done
running = true; running = true;
while(running) { while(running) {
running = false; running = false;
for (std::vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it) for (std::vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it)
if ((*it)->IsRunning()) if ((*it)->IsRunning())
running = true; running = true;
usleep(5000); usleep(5000);
} }
status = RUN_FINISHED; status = RUN_FINISHED;
FILE_LOG(logINFO) << "Status: " << runStatusType(status); FILE_LOG(logINFO) << "Status: " << runStatusType(status);
@ -1075,20 +1081,15 @@ void slsReceiverImplementation::stopReceiver(){
tot += dataProcessor[i]->GetNumFramesCaught(); tot += dataProcessor[i]->GetNumFramesCaught();
uint64_t missingpackets = numberOfFrames*generalData->packetsPerFrame-listener[i]->GetPacketsCaught(); uint64_t missingpackets = numberOfFrames*generalData->packetsPerFrame-listener[i]->GetPacketsCaught();
if ((int)missingpackets > 0) { FILE_LOG(((int)missingpackets > 0) ? logINFORED : logINFOGREEN) <<
cprintf(RED, "\n[Port %d]\n",udpPortNum[i]); "Summary of Port " << udpPortNum[i] <<
cprintf(RED, "Missing Packets\t\t: %lld\n",(long long int)missingpackets); "\n\tMissing Packets\t\t: " << missingpackets <<
cprintf(RED, "Complete Frames\t\t: %lld\n",(long long int)dataProcessor[i]->GetNumFramesCaught()); "\n\tComplete Frames\t\t: " << dataProcessor[i]->GetNumFramesCaught() <<
cprintf(RED, "Last Frame Caught\t: %lld\n",(long long int)listener[i]->GetLastFrameIndexCaught()); "\n\tLast Frame Caught\t: " << listener[i]->GetLastFrameIndexCaught();
}else{ }
cprintf(GREEN, "\n[Port %d]\n",udpPortNum[i]); if(!activated) {
cprintf(GREEN, "Missing Packets\t\t: %lld\n",(long long int)missingpackets); FILE_LOG(logINFORED) << "Deactivated Receiver";
cprintf(GREEN, "Complete Frames\t\t: %lld\n",(long long int)dataProcessor[i]->GetNumFramesCaught());
cprintf(GREEN, "Last Frame Caught\t: %lld\n",(long long int)listener[i]->GetLastFrameIndexCaught());
}
} }
if(!activated)
cprintf(RED,"Note: Deactivated Receiver\n");
//callback //callback
if (acquisitionFinishedCallBack) if (acquisitionFinishedCallBack)
acquisitionFinishedCallBack((tot/numThreads), pAcquisitionFinished); acquisitionFinishedCallBack((tot/numThreads), pAcquisitionFinished);
@ -1104,6 +1105,7 @@ void slsReceiverImplementation::stopReceiver(){
void slsReceiverImplementation::startReadout(){ void slsReceiverImplementation::startReadout(){
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if(status == RUNNING){ if(status == RUNNING){
// wait for incoming delayed packets // wait for incoming delayed packets
@ -1117,11 +1119,8 @@ void slsReceiverImplementation::startReadout(){
//wait as long as there is change from prev totalP, //wait as long as there is change from prev totalP,
while(prev != totalP){ while(prev != totalP){
#ifdef VERY_VERBOSE FILE_LOG(logDEBUG3) << "waiting for all packets prevP:" << prev <<
cprintf(MAGENTA,"waiting for all packets prevP:%d totalP:%d\n", " totalP: " << totalP;
prev,totalP);
#endif
//usleep(1*1000*1000);usleep(1*1000*1000);usleep(1*1000*1000);usleep(1*1000*1000); //usleep(1*1000*1000);usleep(1*1000*1000);usleep(1*1000*1000);usleep(1*1000*1000);
usleep(5*1000);/* Need to find optimal time **/ usleep(5*1000);/* Need to find optimal time **/
@ -1130,9 +1129,7 @@ void slsReceiverImplementation::startReadout(){
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
totalP += (*it)->GetPacketsCaught(); totalP += (*it)->GetPacketsCaught();
#ifdef VERY_VERBOSE FILE_LOG(logDEBUG3) << "\tupdated: totalP:" << totalP;
cprintf(MAGENTA,"\tupdated: totalP:%d\n",totalP);
#endif
} }
} }
@ -1147,6 +1144,7 @@ void slsReceiverImplementation::startReadout(){
void slsReceiverImplementation::shutDownUDPSockets() { void slsReceiverImplementation::shutDownUDPSockets() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
(*it)->ShutDownUDPSocket(); (*it)->ShutDownUDPSocket();
} }
@ -1154,6 +1152,7 @@ void slsReceiverImplementation::shutDownUDPSockets() {
void slsReceiverImplementation::closeFiles() { void slsReceiverImplementation::closeFiles() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
uint64_t maxIndexCaught = 0; uint64_t maxIndexCaught = 0;
bool anycaught = false; bool anycaught = false;
for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) { for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) {
@ -1168,6 +1167,7 @@ void slsReceiverImplementation::closeFiles() {
int slsReceiverImplementation::restreamStop() { int slsReceiverImplementation::restreamStop() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
bool ret = OK; bool ret = OK;
for (std::vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it) { for (std::vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it) {
if ((*it)->RestreamStop() == FAIL) if ((*it)->RestreamStop() == FAIL)
@ -1202,40 +1202,41 @@ void slsReceiverImplementation::registerCallBackRawDataReady(void (*func)(char*
} }
void slsReceiverImplementation::registerCallBackRawDataModifyReady(void (*func)(char* , void slsReceiverImplementation::registerCallBackRawDataModifyReady(void (*func)(char* ,
char*, uint32_t&, void*),void *arg){ char*, uint32_t&, void*),void *arg){
rawDataModifyReadyCallBack=func; rawDataModifyReadyCallBack=func;
pRawDataReady=arg; pRawDataReady=arg;
} }
void slsReceiverImplementation::SetLocalNetworkParameters() { void slsReceiverImplementation::SetLocalNetworkParameters() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
// to increase Max length of input packet queue // to increase Max length of input packet queue
int max_back_log; int max_back_log;
const char *proc_file_name = "/proc/sys/net/core/netdev_max_backlog"; const char *proc_file_name = "/proc/sys/net/core/netdev_max_backlog";
{ {
std::ifstream proc_file(proc_file_name); std::ifstream proc_file(proc_file_name);
proc_file >> max_back_log; proc_file >> max_back_log;
} }
if (max_back_log < MAX_SOCKET_INPUT_PACKET_QUEUE) { if (max_back_log < MAX_SOCKET_INPUT_PACKET_QUEUE) {
std::ofstream proc_file(proc_file_name); std::ofstream proc_file(proc_file_name);
if (proc_file.good()) { if (proc_file.good()) {
proc_file << MAX_SOCKET_INPUT_PACKET_QUEUE << std::endl; proc_file << MAX_SOCKET_INPUT_PACKET_QUEUE << std::endl;
cprintf(GREEN, "Max length of input packet queue " FILE_LOG(logINFOBLUE) << "Max length of input packet queue "
"[/proc/sys/net/core/netdev_max_backlog] modified to %d\n", "[/proc/sys/net/core/netdev_max_backlog] modified to " <<
MAX_SOCKET_INPUT_PACKET_QUEUE); MAX_SOCKET_INPUT_PACKET_QUEUE;
} else { } else {
const char *msg = "Could not change max length of " FILE_LOG(logWARNING) << "Could not change max length of "
"input packet queue [net.core.netdev_max_backlog]. (No Root Privileges?)"; "input packet queue [net.core.netdev_max_backlog]. (No Root Privileges?)";
FILE_LOG(logWARNING) << msg; }
}
} }
} }
void slsReceiverImplementation::SetThreadPriorities() { void slsReceiverImplementation::SetThreadPriorities() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it){ for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it){
if ((*it)->SetThreadPriority(LISTENER_PRIORITY) == FAIL) { if ((*it)->SetThreadPriority(LISTENER_PRIORITY) == FAIL) {
@ -1252,7 +1253,8 @@ void slsReceiverImplementation::SetThreadPriorities() {
int slsReceiverImplementation::SetupFifoStructure() { int slsReceiverImplementation::SetupFifoStructure() {
numberofJobs = 1; FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
numberofJobs = 1;
for (std::vector<Fifo*>::const_iterator it = fifo.begin(); it != fifo.end(); ++it) for (std::vector<Fifo*>::const_iterator it = fifo.begin(); it != fifo.end(); ++it)
@ -1261,18 +1263,18 @@ int slsReceiverImplementation::SetupFifoStructure() {
for ( int i = 0; i < numThreads; ++i ) { for ( int i = 0; i < numThreads; ++i ) {
//create fifo structure //create fifo structure
try { try {
Fifo* f = new Fifo (i, Fifo* f = new Fifo (i,
(generalData->imageSize) * numberofJobs + (generalData->fifoBufferHeaderSize), (generalData->imageSize) * numberofJobs + (generalData->fifoBufferHeaderSize),
fifoDepth); fifoDepth);
fifo.push_back(f); fifo.push_back(f);
} catch (...) { } catch (...) {
cprintf(RED,"Error: Could not allocate memory for fifo structure of index %d\n", i); FILE_LOG(logERROR) << "Could not allocate memory for fifo structure of index " << i;
for (std::vector<Fifo*>::const_iterator it = fifo.begin(); it != fifo.end(); ++it) for (std::vector<Fifo*>::const_iterator it = fifo.begin(); it != fifo.end(); ++it)
delete(*it); delete(*it);
fifo.clear(); fifo.clear();
return FAIL; return FAIL;
} }
//set the listener & dataprocessor threads to point to the right fifo //set the listener & dataprocessor threads to point to the right fifo
if(listener.size())listener[i]->SetFifo(fifo[i]); if(listener.size())listener[i]->SetFifo(fifo[i]);
if(dataProcessor.size())dataProcessor[i]->SetFifo(fifo[i]); if(dataProcessor.size())dataProcessor[i]->SetFifo(fifo[i]);
@ -1287,6 +1289,7 @@ int slsReceiverImplementation::SetupFifoStructure() {
void slsReceiverImplementation::ResetParametersforNewMeasurement() { void slsReceiverImplementation::ResetParametersforNewMeasurement() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
(*it)->ResetParametersforNewMeasurement(); (*it)->ResetParametersforNewMeasurement();
for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it) for (std::vector<DataProcessor*>::const_iterator it = dataProcessor.begin(); it != dataProcessor.end(); ++it)
@ -1303,6 +1306,7 @@ void slsReceiverImplementation::ResetParametersforNewMeasurement() {
int slsReceiverImplementation::CreateUDPSockets() { int slsReceiverImplementation::CreateUDPSockets() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
bool error = false; bool error = false;
for (unsigned int i = 0; i < listener.size(); ++i) for (unsigned int i = 0; i < listener.size(); ++i)
if (listener[i]->CreateUDPSockets() == FAIL) { if (listener[i]->CreateUDPSockets() == FAIL) {
@ -1320,6 +1324,7 @@ int slsReceiverImplementation::CreateUDPSockets() {
int slsReceiverImplementation::SetupWriter() { int slsReceiverImplementation::SetupWriter() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
bool error = false; bool error = false;
for (unsigned int i = 0; i < dataProcessor.size(); ++i) for (unsigned int i = 0; i < dataProcessor.size(); ++i)
if (dataProcessor[i]->CreateNewFile(tengigaEnable, if (dataProcessor[i]->CreateNewFile(tengigaEnable,
@ -1338,6 +1343,7 @@ int slsReceiverImplementation::SetupWriter() {
void slsReceiverImplementation::StartRunning() { void slsReceiverImplementation::StartRunning() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
//set running mask and post semaphore to start the inner loop in execution thread //set running mask and post semaphore to start the inner loop in execution thread
for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) { for (std::vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) {
(*it)->StartRunning(); (*it)->StartRunning();

171
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@ -141,7 +141,7 @@ void* slsReceiverTCPIPInterface::startTCPServerThread(void *this_pointer){
void slsReceiverTCPIPInterface::startTCPServer(){ void slsReceiverTCPIPInterface::startTCPServer(){
cprintf(BLUE,"Created [ TCP server Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " << syscall(SYS_gettid) << "]";;
FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port " << portNumber << std::endl; FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port " << portNumber << std::endl;
int ret = OK; int ret = OK;
@ -159,7 +159,7 @@ void slsReceiverTCPIPInterface::startTCPServer(){
} }
mySock->exitServer(); mySock->exitServer();
cprintf(BLUE,"Exiting [ TCP server Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) <<"]";
pthread_exit(NULL); pthread_exit(NULL);
} }
@ -170,7 +170,7 @@ void slsReceiverTCPIPInterface::startTCPServer(){
receiver->shutDownUDPSockets(); receiver->shutDownUDPSockets();
} }
} }
cprintf(BLUE,"Exiting [ TCP server Tid: %ld ]\n", (long)syscall(SYS_gettid)); FILE_LOG(logINFOBLUE) << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) <<"]";
pthread_exit(NULL); pthread_exit(NULL);
} }
} }
@ -229,7 +229,7 @@ int slsReceiverTCPIPInterface::function_table(){
flist[F_RECEIVER_DEACTIVATED_PADDING_ENABLE] = &slsReceiverTCPIPInterface::set_deactivated_receiver_padding_enable; flist[F_RECEIVER_DEACTIVATED_PADDING_ENABLE] = &slsReceiverTCPIPInterface::set_deactivated_receiver_padding_enable;
for (int i = NUM_DET_FUNCTIONS + 1; i < NUM_REC_FUNCTIONS ; i++) { for (int i = NUM_DET_FUNCTIONS + 1; i < NUM_REC_FUNCTIONS ; i++) {
FILE_LOG(logDEBUG5) << "function fnum: " << i << " (" << FILE_LOG(logDEBUG1) << "function fnum: " << i << " (" <<
getFunctionNameFromEnum((enum detFuncs)i) << ") located at " << flist[i]; getFunctionNameFromEnum((enum detFuncs)i) << ") located at " << flist[i];
} }
@ -243,28 +243,29 @@ int slsReceiverTCPIPInterface::decode_function(){
ret = FAIL; ret = FAIL;
int n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum)); int n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum));
if (n <= 0) { if (n <= 0) {
FILE_LOG(logDEBUG5) << "Could not read socket. " FILE_LOG(logDEBUG3) << "Could not read socket. "
"Received " << n << " bytes," << "Received " << n << " bytes," <<
"fnum:" << fnum << " " "fnum:" << fnum << " "
"(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; "(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ")";
return FAIL; return FAIL;
} }
else else
FILE_LOG(logDEBUG5) << "Received " << n << " bytes"; FILE_LOG(logDEBUG3) << "Received " << n << " bytes";
if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) { if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) {
FILE_LOG(logERROR) << "Unknown function enum " << fnum; FILE_LOG(logERROR) << "Unknown function enum " << fnum;
ret = (this->M_nofunc)(); ret = (this->M_nofunc)();
} else{ } else{
FILE_LOG(logDEBUG5) << "calling function fnum: "<< fnum << " " FILE_LOG(logDEBUG1) << "calling function fnum: "<< fnum << " "
"(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ") " "(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ") "
"located at " << flist[fnum]; "located at " << flist[fnum];
ret = (this->*flist[fnum])(); ret = (this->*flist[fnum])();
if (ret == FAIL) { if (ret == FAIL) {
FILE_LOG(logDEBUG5) << "Failed to execute function = " << fnum << " (" FILE_LOG(logDEBUG1) << "Failed to execute function = " << fnum << " ("
<< getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; << getFunctionNameFromEnum((enum detFuncs)fnum) << ")";
} } else FILE_LOG(logDEBUG1) << "Function " <<
getFunctionNameFromEnum((enum detFuncs)fnum) << " executed OK";
} }
return ret; return ret;
} }
@ -352,7 +353,7 @@ int slsReceiverTCPIPInterface::exec_command() {
int slsReceiverTCPIPInterface::exit_server() { int slsReceiverTCPIPInterface::exit_server() {
cprintf(BG_RED, "Closing server\n"); FILE_LOG(logINFO) << "Closing server";
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
interface->Server_SendResult(false, ret, NULL, 0); interface->Server_SendResult(false, ret, NULL, 0);
@ -369,7 +370,7 @@ int slsReceiverTCPIPInterface::lock_receiver() {
// get args, return if socket crashed // get args, return if socket crashed
if (interface->Server_ReceiveArg(ret, mess, &lock, sizeof(lock)) == FAIL) if (interface->Server_ReceiveArg(ret, mess, &lock, sizeof(lock)) == FAIL)
return FAIL; return FAIL;
FILE_LOG(logDEBUG5) << "Locking Server to " << lock; FILE_LOG(logDEBUG1) << "Locking Server to " << lock;
// execute action // execute action
if (lock >= 0) { if (lock >= 0) {
@ -642,7 +643,7 @@ int slsReceiverTCPIPInterface::set_detector_hostname() {
// get // get
std::string s = receiver->getDetectorHostname(); std::string s = receiver->getDetectorHostname();
strcpy(retval, s.c_str()); strcpy(retval, s.c_str());
if (s.length()) { if (!s.length()) {
ret = FAIL; ret = FAIL;
sprintf(mess, "hostname not set\n"); sprintf(mess, "hostname not set\n");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
@ -675,9 +676,9 @@ int slsReceiverTCPIPInterface::set_roi() {
return interface->Server_SocketCrash(); return interface->Server_SocketCrash();
arg.push_back(temp); arg.push_back(temp);
} }
FILE_LOG(logDEBUG5) << "Set ROI narg: " << narg; FILE_LOG(logDEBUG1) << "Set ROI narg: " << narg;
for (int iloop = 0; iloop < narg; ++iloop) { for (int iloop = 0; iloop < narg; ++iloop) {
FILE_LOG(logDEBUG5) << "(" << arg[iloop].xmin << ", " << FILE_LOG(logDEBUG1) << "(" << arg[iloop].xmin << ", " <<
arg[iloop].xmax << ", " << arg[iloop].ymin << ", " << arg[iloop].xmax << ", " << arg[iloop].ymin << ", " <<
arg[iloop].ymax << ")"; arg[iloop].ymax << ")";
} }
@ -705,7 +706,7 @@ int slsReceiverTCPIPInterface::setup_udp(){
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char args[3][MAX_STR_LENGTH] = {0}; char args[3][MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH] = {0}; char retvals[MAX_STR_LENGTH] = {0};
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null
if (interface->Server_ReceiveArg(ret, mess, args, sizeof(args), true, receiver) == FAIL) if (interface->Server_ReceiveArg(ret, mess, args, sizeof(args), true, receiver) == FAIL)
@ -755,13 +756,13 @@ int slsReceiverTCPIPInterface::setup_udp(){
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} }
else { else {
strcpy(retval,temp.c_str()); strcpy(retvals,temp.c_str());
FILE_LOG(logINFO) << "Reciever MAC Address: " << retval; FILE_LOG(logINFO) << "Reciever MAC Address: " << retvals;
} }
} }
} }
} }
return interface->Server_SendResult(true, ret, retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, retvals, sizeof(retvals), mess);
} }
@ -778,7 +779,7 @@ int slsReceiverTCPIPInterface::set_timer() {
// base object not null // base object not null
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5) << "Setting timer index " << index[0] << " to " << index[1]; FILE_LOG(logDEBUG1) << "Setting timer index " << index[0] << " to " << index[1];
// set // set
if (index[1] >= 0) { if (index[1] >= 0) {
@ -848,7 +849,7 @@ int slsReceiverTCPIPInterface::set_timer() {
break; break;
} }
validate((int)index[1], (int)retval, std::string("set timer"), 0); validate((int)index[1], (int)retval, std::string("set timer"), 0);
FILE_LOG(logDEBUG5) << slsDetectorDefs::getTimerType((timerIndex)(index[0])) << ":" << retval; FILE_LOG(logDEBUG1) << slsDetectorDefs::getTimerType((timerIndex)(index[0])) << ":" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -871,7 +872,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range() {
if (dr >= 0) { if (dr >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting dynamic range: " << dr; FILE_LOG(logDEBUG1) << "Setting dynamic range: " << dr;
bool exists = false; bool exists = false;
switch (dr) { switch (dr) {
case 16: case 16:
@ -903,7 +904,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range() {
// get // get
retval = receiver->getDynamicRange(); retval = receiver->getDynamicRange();
validate(dr, retval, std::string("set dynamic range"), 0); validate(dr, retval, std::string("set dynamic range"), 0);
FILE_LOG(logDEBUG5) << "dynamic range: " << retval; FILE_LOG(logDEBUG1) << "dynamic range: " << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -926,7 +927,7 @@ int slsReceiverTCPIPInterface::set_streaming_frequency() {
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting streaming frequency: " << index; FILE_LOG(logDEBUG1) << "Setting streaming frequency: " << index;
ret = receiver->setStreamingFrequency(index); ret = receiver->setStreamingFrequency(index);
if(ret == FAIL) { if(ret == FAIL) {
strcpy(mess, "Could not allocate memory for listening fifo\n"); strcpy(mess, "Could not allocate memory for listening fifo\n");
@ -952,9 +953,9 @@ int slsReceiverTCPIPInterface::get_status(){
interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver); interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver);
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5) << "Getting Status"; FILE_LOG(logDEBUG1) << "Getting Status";
retval = receiver->getStatus(); retval = receiver->getStatus();
FILE_LOG(logDEBUG5) << "Status:" << runStatusType(retval); FILE_LOG(logDEBUG1) << "Status:" << runStatusType(retval);
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -980,7 +981,7 @@ int slsReceiverTCPIPInterface::start_receiver(){
sprintf(mess,"Cannot start Receiver as it is in %s state\n",runStatusType(s).c_str()); sprintf(mess,"Cannot start Receiver as it is in %s state\n",runStatusType(s).c_str());
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
}else { }else {
FILE_LOG(logDEBUG5) << "Starting Reciever"; FILE_LOG(logDEBUG1) << "Starting Reciever";
ret = receiver->startReceiver(mess); ret = receiver->startReceiver(mess);
if (ret == FAIL) { if (ret == FAIL) {
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
@ -1006,7 +1007,7 @@ int slsReceiverTCPIPInterface::stop_receiver(){
// verify if receiver is unlocked // verify if receiver is unlocked
if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) {
if(receiver->getStatus() != IDLE) { if(receiver->getStatus() != IDLE) {
FILE_LOG(logDEBUG5) << "Stopping Reciever"; FILE_LOG(logDEBUG1) << "Stopping Reciever";
receiver->stopReceiver(); receiver->stopReceiver();
} }
enum runStatus s = receiver->getStatus(); enum runStatus s = receiver->getStatus();
@ -1038,18 +1039,18 @@ int slsReceiverTCPIPInterface::set_file_dir() {
if (ret == OK) { if (ret == OK) {
// set // set
if (strlen(fPath)) { if (strlen(fPath)) {
FILE_LOG(logDEBUG5) << "Setting file path: " << fPath; FILE_LOG(logDEBUG1) << "Setting file path: " << fPath;
receiver->setFilePath(fPath); receiver->setFilePath(fPath);
} }
// get // get
std::string s = receiver->getFilePath(); std::string s = receiver->getFilePath();
strcpy(retval, s.c_str()); strcpy(retval, s.c_str());
if ((s.length()) || (strlen(fPath) && strcasecmp(fPath, retval))) { if ((!s.length()) || (strlen(fPath) && strcasecmp(fPath, retval))) {
ret = FAIL; ret = FAIL;
strcpy(mess,"receiver file path does not exist\n"); strcpy(mess,"receiver file path does not exist\n");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} else } else
FILE_LOG(logDEBUG5) << "file path:" << retval; FILE_LOG(logDEBUG1) << "file path:" << retval;
} }
return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess);
} }
@ -1070,18 +1071,18 @@ int slsReceiverTCPIPInterface::set_file_name() {
if (ret == OK) { if (ret == OK) {
// set // set
if (strlen(fName)) { if (strlen(fName)) {
FILE_LOG(logDEBUG5) << "Setting file name: " << fName; FILE_LOG(logDEBUG1) << "Setting file name: " << fName;
receiver->setFileName(fName); receiver->setFileName(fName);
} }
// get // get
std::string s = receiver->getFileName(); std::string s = receiver->getFileName();
strcpy(retval, s.c_str()); strcpy(retval, s.c_str());
if (s.length()) { if (!s.length()) {
ret = FAIL; ret = FAIL;
strcpy(mess, "file name is empty\n"); strcpy(mess, "file name is empty\n");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} else } else
FILE_LOG(logDEBUG5) << "file name:" << retval; FILE_LOG(logDEBUG1) << "file name:" << retval;
} }
return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess);
} }
@ -1104,14 +1105,14 @@ int slsReceiverTCPIPInterface::set_file_index() {
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting file index: " << index; FILE_LOG(logDEBUG1) << "Setting file index: " << index;
receiver->setFileIndex(index); receiver->setFileIndex(index);
} }
} }
// get // get
retval=receiver->getFileIndex(); retval=receiver->getFileIndex();
validate(index, retval, std::string("set file index"), 0); validate(index, retval, std::string("set file index"), 0);
FILE_LOG(logDEBUG5) << "file index:" << retval; FILE_LOG(logDEBUG1) << "file index:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess);
} }
@ -1127,9 +1128,9 @@ int slsReceiverTCPIPInterface::get_frame_index(){
interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver); interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver);
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5) << "Getting frame index"; FILE_LOG(logDEBUG1) << "Getting frame index";
retval = receiver->getAcquisitionIndex(); retval = receiver->getAcquisitionIndex();
FILE_LOG(logDEBUG5) << "frame index:" << retval; FILE_LOG(logDEBUG1) << "frame index:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess);
} }
@ -1145,9 +1146,9 @@ int slsReceiverTCPIPInterface::get_frames_caught(){
interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver); interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver);
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5) << "Getting frames caught"; FILE_LOG(logDEBUG1) << "Getting frames caught";
retval = receiver->getTotalFramesCaught(); retval = receiver->getTotalFramesCaught();
FILE_LOG(logDEBUG5) << "frames caught:" << retval; FILE_LOG(logDEBUG1) << "frames caught:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess);
} }
@ -1166,7 +1167,7 @@ int slsReceiverTCPIPInterface::reset_frames_caught(){
// only set // only set
// verify if receiver is unlocked // verify if receiver is unlocked
if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) {
FILE_LOG(logDEBUG5) << "Reset frames caught"; FILE_LOG(logDEBUG1) << "Reset frames caught";
receiver->resetAcquisitionCount(); receiver->resetAcquisitionCount();
} }
} }
@ -1191,14 +1192,14 @@ int slsReceiverTCPIPInterface::enable_file_write(){
if (enable >= 0) { if (enable >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting File write enable:" << enable; FILE_LOG(logDEBUG1) << "Setting File write enable:" << enable;
receiver->setFileWriteEnable(enable); receiver->setFileWriteEnable(enable);
} }
} }
// get // get
retval = receiver->getFileWriteEnable(); retval = receiver->getFileWriteEnable();
validate(enable, retval, std::string("set file write enable"), 0); validate(enable, retval, std::string("set file write enable"), 0);
FILE_LOG(logDEBUG5) << "file write enable:" << retval; FILE_LOG(logDEBUG1) << "file write enable:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1221,14 +1222,14 @@ int slsReceiverTCPIPInterface::enable_overwrite() {
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting File overwrite enable:" << index; FILE_LOG(logDEBUG1) << "Setting File overwrite enable:" << index;
receiver->setOverwriteEnable(index); receiver->setOverwriteEnable(index);
} }
} }
// get // get
retval = receiver->getOverwriteEnable(); retval = receiver->getOverwriteEnable();
validate(index, retval, std::string("set file overwrite enable"), 0); validate(index, retval, std::string("set file overwrite enable"), 0);
FILE_LOG(logDEBUG5) << "file overwrite enable:" << retval; FILE_LOG(logDEBUG1) << "file overwrite enable:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1254,14 +1255,14 @@ int slsReceiverTCPIPInterface::enable_tengiga() {
if (val >= 0) { if (val >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting 10GbE:" << val; FILE_LOG(logDEBUG1) << "Setting 10GbE:" << val;
ret = receiver->setTenGigaEnable(val); ret = receiver->setTenGigaEnable(val);
} }
} }
// get // get
retval = receiver->getTenGigaEnable(); retval = receiver->getTenGigaEnable();
validate(val, retval, std::string("set 10GbE"), 0); validate(val, retval, std::string("set 10GbE"), 0);
FILE_LOG(logDEBUG5) << "10Gbe:" << retval; FILE_LOG(logDEBUG1) << "10Gbe:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1284,7 +1285,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth() {
if (value >= 0) { if (value >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting fifo depth:" << value; FILE_LOG(logDEBUG1) << "Setting fifo depth:" << value;
ret = receiver->setFifoDepth(value); ret = receiver->setFifoDepth(value);
if (ret == FAIL) { if (ret == FAIL) {
strcpy(mess,"Could not set fifo depth"); strcpy(mess,"Could not set fifo depth");
@ -1295,7 +1296,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth() {
// get // get
retval = receiver->getFifoDepth(); retval = receiver->getFifoDepth();
validate(value, retval, std::string("set fifo depth"), 0); validate(value, retval, std::string("set fifo depth"), 0);
FILE_LOG(logDEBUG5) << "fifo depth:" << retval; FILE_LOG(logDEBUG1) << "fifo depth:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1321,14 +1322,14 @@ int slsReceiverTCPIPInterface::set_activate() {
if (enable >= 0) { if (enable >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting activate:" << enable; FILE_LOG(logDEBUG1) << "Setting activate:" << enable;
receiver->setActivate(enable > 0 ? true : false); receiver->setActivate(enable > 0 ? true : false);
} }
} }
// get // get
retval = (int)receiver->getActivate(); retval = (int)receiver->getActivate();
validate(enable, retval, std::string("set activate"), 0); validate(enable, retval, std::string("set activate"), 0);
FILE_LOG(logDEBUG5) << "Activate: " << retval; FILE_LOG(logDEBUG1) << "Activate: " << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1351,14 +1352,14 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting data stream enable:" << index; FILE_LOG(logDEBUG1) << "Setting data stream enable:" << index;
ret = receiver->setDataStreamEnable(index); ret = receiver->setDataStreamEnable(index);
} }
} }
// get // get
retval = receiver->getDataStreamEnable(); retval = receiver->getDataStreamEnable();
validate(index, retval, std::string("set data stream enable"), 0); validate(index, retval, std::string("set data stream enable"), 0);
FILE_LOG(logDEBUG5) << "data streaming enable:" << retval; FILE_LOG(logDEBUG1) << "data streaming enable:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1381,14 +1382,14 @@ int slsReceiverTCPIPInterface::set_streaming_timer(){
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting streaming timer:" << index; FILE_LOG(logDEBUG1) << "Setting streaming timer:" << index;
receiver->setStreamingTimer(index); receiver->setStreamingTimer(index);
} }
} }
// get // get
retval=receiver->getStreamingTimer(); retval=receiver->getStreamingTimer();
validate(index, retval, std::string("set data stream timer"), 0); validate(index, retval, std::string("set data stream timer"), 0);
FILE_LOG(logDEBUG5) << "Streaming timer:" << retval; FILE_LOG(logDEBUG1) << "Streaming timer:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1414,14 +1415,14 @@ int slsReceiverTCPIPInterface::set_flipped_data(){
if (args[1] >= 0) { if (args[1] >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting flipped data:" << args[1]; FILE_LOG(logDEBUG1) << "Setting flipped data:" << args[1];
receiver->setFlippedData(args[0],args[1]); receiver->setFlippedData(args[0],args[1]);
} }
} }
// get // get
retval=receiver->getFlippedData(args[0]); retval=receiver->getFlippedData(args[0]);
validate(args[1], retval, std::string("set flipped data"), 0); validate(args[1], retval, std::string("set flipped data"), 0);
FILE_LOG(logDEBUG5) << "Flipped Data:" << retval; FILE_LOG(logDEBUG1) << "Flipped Data:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1444,14 +1445,14 @@ int slsReceiverTCPIPInterface::set_file_format() {
if (f >= 0) { if (f >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting file format:" << f; FILE_LOG(logDEBUG1) << "Setting file format:" << f;
receiver->setFileFormat(f); receiver->setFileFormat(f);
} }
} }
// get // get
retval = receiver->getFileFormat(); retval = receiver->getFileFormat();
validate(f, retval, std::string("set file format"), 0); validate(f, retval, std::string("set file format"), 0);
FILE_LOG(logDEBUG5) << "File Format: " << retval; FILE_LOG(logDEBUG1) << "File Format: " << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1474,14 +1475,14 @@ int slsReceiverTCPIPInterface::set_detector_posid() {
if (arg >= 0) { if (arg >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting detector position id:" << arg; FILE_LOG(logDEBUG1) << "Setting detector position id:" << arg;
receiver->setDetectorPositionId(arg); receiver->setDetectorPositionId(arg);
} }
} }
// get // get
retval = receiver->getDetectorPositionId(); retval = receiver->getDetectorPositionId();
validate(arg, retval, std::string("set detector position id"), 0); validate(arg, retval, std::string("set detector position id"), 0);
FILE_LOG(logDEBUG5) << "Position Id:" << retval; FILE_LOG(logDEBUG1) << "Position Id:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1504,7 +1505,7 @@ int slsReceiverTCPIPInterface::set_multi_detector_size() {
if((arg[0] > 0) && (arg[1] > 0)) { if((arg[0] > 0) && (arg[1] > 0)) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting multi detector size:" << arg[0] << "," << arg[1]; FILE_LOG(logDEBUG1) << "Setting multi detector size:" << arg[0] << "," << arg[1];
receiver->setMultiDetectorSize(arg); receiver->setMultiDetectorSize(arg);
} }
} }
@ -1516,7 +1517,7 @@ int slsReceiverTCPIPInterface::set_multi_detector_size() {
else else
retval *= temp[i]; retval *= temp[i];
} }
FILE_LOG(logDEBUG5) << "Multi Detector Size:" << retval; FILE_LOG(logDEBUG1) << "Multi Detector Size:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1539,14 +1540,14 @@ int slsReceiverTCPIPInterface::set_streaming_port() {
if (port >= 0) { if (port >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting streaming port:" << port; FILE_LOG(logDEBUG1) << "Setting streaming port:" << port;
receiver->setStreamingPort(port); receiver->setStreamingPort(port);
} }
} }
// get // get
retval = receiver->getStreamingPort(); retval = receiver->getStreamingPort();
validate(port, retval, std::string("set streaming port"), 0); validate(port, retval, std::string("set streaming port"), 0);
FILE_LOG(logDEBUG5) << "streaming port:" << retval; FILE_LOG(logDEBUG1) << "streaming port:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1568,12 +1569,12 @@ int slsReceiverTCPIPInterface::set_streaming_source_ip() {
// only set // only set
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting streaming source ip:" << arg; FILE_LOG(logDEBUG1) << "Setting streaming source ip:" << arg;
receiver->setStreamingSourceIP(arg); receiver->setStreamingSourceIP(arg);
} }
// get // get
strcpy(retval, receiver->getStreamingSourceIP().c_str()); strcpy(retval, receiver->getStreamingSourceIP().c_str());
FILE_LOG(logDEBUG5) << "streaming source ip:" << retval; FILE_LOG(logDEBUG1) << "streaming source ip:" << retval;
} }
return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess);
} }
@ -1596,14 +1597,14 @@ int slsReceiverTCPIPInterface::set_silent_mode() {
if (value >= 0) { if (value >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting silent mode:" << value; FILE_LOG(logDEBUG1) << "Setting silent mode:" << value;
receiver->setSilentMode(value); receiver->setSilentMode(value);
} }
} }
// get // get
retval = (int)receiver->getSilentMode(); retval = (int)receiver->getSilentMode();
validate(value, retval, std::string("set silent mode"), 0); validate(value, retval, std::string("set silent mode"), 0);
FILE_LOG(logDEBUG5) << "silent mode:" << retval; FILE_LOG(logDEBUG1) << "silent mode:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1629,14 +1630,14 @@ int slsReceiverTCPIPInterface::enable_gap_pixels() {
if (enable >= 0) { if (enable >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting gap pixels enable:" << enable; FILE_LOG(logDEBUG1) << "Setting gap pixels enable:" << enable;
receiver->setGapPixelsEnable(enable); receiver->setGapPixelsEnable(enable);
} }
} }
// get // get
retval = receiver->getGapPixelsEnable(); retval = receiver->getGapPixelsEnable();
validate(enable, retval, std::string("set gap pixels enable"), 0); validate(enable, retval, std::string("set gap pixels enable"), 0);
FILE_LOG(logDEBUG5) << "Gap Pixels Enable: " << retval; FILE_LOG(logDEBUG1) << "Gap Pixels Enable: " << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1660,7 +1661,7 @@ int slsReceiverTCPIPInterface::restream_stop(){
sprintf(mess,"Could not restream stop packet as data Streaming is disabled.\n"); sprintf(mess,"Could not restream stop packet as data Streaming is disabled.\n");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} else { } else {
FILE_LOG(logDEBUG5) << "Restreaming stop"; FILE_LOG(logDEBUG1) << "Restreaming stop";
ret = receiver->restreamStop(); ret = receiver->restreamStop();
if (ret == FAIL) { if (ret == FAIL) {
sprintf(mess,"Could not restream stop packet.\n"); sprintf(mess,"Could not restream stop packet.\n");
@ -1689,12 +1690,12 @@ int slsReceiverTCPIPInterface::set_additional_json_header() {
// only set // only set
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting additional json header: " << arg; FILE_LOG(logDEBUG1) << "Setting additional json header: " << arg;
receiver->setAdditionalJsonHeader(arg); receiver->setAdditionalJsonHeader(arg);
} }
// get // get
strcpy(retval, receiver->getAdditionalJsonHeader().c_str()); strcpy(retval, receiver->getAdditionalJsonHeader().c_str());
FILE_LOG(logDEBUG5) << "additional json header:" << retval; FILE_LOG(logDEBUG1) << "additional json header:" << retval;
} }
return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess);
} }
@ -1717,7 +1718,7 @@ int slsReceiverTCPIPInterface::set_udp_socket_buffer_size() {
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting UDP Socket Buffer size: " << index; FILE_LOG(logDEBUG1) << "Setting UDP Socket Buffer size: " << index;
if (receiver->setUDPSocketBufferSize(index) == FAIL) { if (receiver->setUDPSocketBufferSize(index) == FAIL) {
ret = FAIL; ret = FAIL;
strcpy(mess, "Could not create dummy UDP Socket to test buffer size\n"); strcpy(mess, "Could not create dummy UDP Socket to test buffer size\n");
@ -1728,7 +1729,7 @@ int slsReceiverTCPIPInterface::set_udp_socket_buffer_size() {
// get // get
retval = receiver->getUDPSocketBufferSize(); retval = receiver->getUDPSocketBufferSize();
validate(index, retval, std::string("set udp socket buffer size (No CAP_NET_ADMIN privileges?)"), 0); validate(index, retval, std::string("set udp socket buffer size (No CAP_NET_ADMIN privileges?)"), 0);
FILE_LOG(logDEBUG5) << "UDP Socket Buffer Size:" << retval; FILE_LOG(logDEBUG1) << "UDP Socket Buffer Size:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1744,7 +1745,7 @@ int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size(){
interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver); interface->Server_ReceiveArg(ret, mess, NULL, 0, true, receiver);
if (ret == OK) { if (ret == OK) {
FILE_LOG(logDEBUG5) << "Getting actual UDP buffer size"; FILE_LOG(logDEBUG1) << "Getting actual UDP buffer size";
retval = receiver->getActualUDPSocketBufferSize(); retval = receiver->getActualUDPSocketBufferSize();
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
@ -1768,14 +1769,14 @@ int slsReceiverTCPIPInterface::set_frames_per_file() {
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting frames per file: " << index; FILE_LOG(logDEBUG1) << "Setting frames per file: " << index;
receiver->setFramesPerFile(index); receiver->setFramesPerFile(index);
} }
} }
// get // get
retval = receiver->getFramesPerFile(); retval = receiver->getFramesPerFile();
validate(index, retval, std::string("set frames per file"), 0); validate(index, retval, std::string("set frames per file"), 0);
FILE_LOG(logDEBUG5) << "frames per file:" << retval; FILE_LOG(logDEBUG1) << "frames per file:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1790,7 +1791,7 @@ int slsReceiverTCPIPInterface::check_version_compatibility() {
// get args, return if socket crashed // get args, return if socket crashed
if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg)) == FAIL) if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg)) == FAIL)
return FAIL; return FAIL;
FILE_LOG(logDEBUG5) << "Checking versioning compatibility with value " << arg; FILE_LOG(logDEBUG1) << "Checking versioning compatibility with value " << arg;
int64_t client_requiredVersion = arg; int64_t client_requiredVersion = arg;
int64_t rx_apiVersion = APIRECEIVER; int64_t rx_apiVersion = APIRECEIVER;
int64_t rx_version = getReceiverVersion(); int64_t rx_version = getReceiverVersion();
@ -1838,14 +1839,14 @@ int slsReceiverTCPIPInterface::set_discard_policy() {
if (index >= 0) { if (index >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting frames discard policy: " << index; FILE_LOG(logDEBUG1) << "Setting frames discard policy: " << index;
receiver->setFrameDiscardPolicy((frameDiscardPolicy)index); receiver->setFrameDiscardPolicy((frameDiscardPolicy)index);
} }
} }
// get // get
retval = receiver->getFrameDiscardPolicy(); retval = receiver->getFrameDiscardPolicy();
validate(index, retval, std::string("set discard policy"), 0); validate(index, retval, std::string("set discard policy"), 0);
FILE_LOG(logDEBUG5) << "frame discard policy:" << retval; FILE_LOG(logDEBUG1) << "frame discard policy:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1869,14 +1870,14 @@ int slsReceiverTCPIPInterface::set_padding_enable() {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
index = (index == 0) ? 0 : 1; index = (index == 0) ? 0 : 1;
FILE_LOG(logDEBUG5) << "Setting frames padding enable: " << index; FILE_LOG(logDEBUG1) << "Setting frames padding enable: " << index;
receiver->setFramePaddingEnable(index); receiver->setFramePaddingEnable(index);
} }
} }
// get // get
retval = (int)receiver->getFramePaddingEnable(); retval = (int)receiver->getFramePaddingEnable();
validate(index, retval, std::string("set frame padding enable"), 0); validate(index, retval, std::string("set frame padding enable"), 0);
FILE_LOG(logDEBUG5) << "Frame Padding Enable:" << retval; FILE_LOG(logDEBUG1) << "Frame Padding Enable:" << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }
@ -1902,14 +1903,14 @@ int slsReceiverTCPIPInterface::set_deactivated_receiver_padding_enable() {
if (enable >= 0) { if (enable >= 0) {
// verify if receiver is unlocked and idle // verify if receiver is unlocked and idle
if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) {
FILE_LOG(logDEBUG5) << "Setting deactivated padding enable: " << enable; FILE_LOG(logDEBUG1) << "Setting deactivated padding enable: " << enable;
receiver->setDeactivatedPadding(enable > 0 ? true : false); receiver->setDeactivatedPadding(enable > 0 ? true : false);
} }
} }
// get // get
retval = (int)receiver->getDeactivatedPadding(); retval = (int)receiver->getDeactivatedPadding();
validate(enable, retval, std::string("set deactivated padding enable"), 0); validate(enable, retval, std::string("set deactivated padding enable"), 0);
FILE_LOG(logDEBUG5) << "Deactivated Padding Enable: " << retval; FILE_LOG(logDEBUG1) << "Deactivated Padding Enable: " << retval;
} }
return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess);
} }

68
slsSupportLib/include/logger.h
View File

@ -36,8 +36,9 @@
inline std::string NowTime(); inline std::string NowTime();
// 1 normal debug, 3 function names, 5 fifodebug
enum TLogLevel {logERROR, logWARNING, logINFO, logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, logDEBUG5}; enum TLogLevel {logERROR, logWARNING, logINFOBLUE, logINFOGREEN, logINFORED, logINFO,
logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, logDEBUG5};
template <typename T> class Log{ template <typename T> class Log{
public: public:
@ -63,20 +64,11 @@ public:
static void Output(const std::string& msg, TLogLevel level); static void Output(const std::string& msg, TLogLevel level);
}; };
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
# if defined (BUILDING_FILELOG_DLL) #define FILELOG_DECLSPEC
# define FILELOG_DECLSPEC __declspec (dllexport)
# elif defined (USING_FILELOG_DLL)
# define FILELOG_DECLSPEC __declspec (dllimport)
# else
# define FILELOG_DECLSPEC
# endif // BUILDING_DBSIMPLE_DLL
#else
# define FILELOG_DECLSPEC
#endif // _WIN32
class FILELOG_DECLSPEC FILELog : public Log<Output2FILE> {}; class FILELOG_DECLSPEC FILELog : public Log<Output2FILE> {};
//typedef Log<Output2FILE> FILELog;
#define FILE_LOG(level) \ #define FILE_LOG(level) \
if (level > FILELOG_MAX_LEVEL) ; \ if (level > FILELOG_MAX_LEVEL) ; \
@ -84,29 +76,6 @@ class FILELOG_DECLSPEC FILELog : public Log<Output2FILE> {};
else FILELog().Get(level) else FILELog().Get(level)
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
#include <windows.h>
inline std::string NowTime()
{
const int MAX_LEN = 200;
char buffer[MAX_LEN];
if (GetTimeFormatA(LOCALE_USER_DEFAULT, 0, 0,
"HH':'mm':'ss", buffer, MAX_LEN) == 0)
return "Error in NowTime()";
char result[100] = {0};
static DWORD first = GetTickCount();
sprintf(result, "%s.%03ld", buffer, (long)(GetTickCount() - first) % 1000);
return result;
}
#else
#include <sys/time.h> #include <sys/time.h>
inline std::string NowTime() inline std::string NowTime()
@ -127,8 +96,6 @@ inline std::string NowTime()
return result; return result;
} }
#endif //WIN32
template <typename T> Log<T>::Log():lev(logDEBUG){} template <typename T> Log<T>::Log():lev(logDEBUG){}
@ -138,7 +105,7 @@ template <typename T> std::ostringstream& Log<T>::Get(TLogLevel level)
os << "- " << NowTime(); os << "- " << NowTime();
os << " " << ToString(level) << ": "; os << " " << ToString(level) << ": ";
if (level > logDEBUG) if (level > logDEBUG)
os << std::string(level - logDEBUG, '\t'); os << std::string(level - logDEBUG, ' ');
return os; return os;
} }
@ -156,7 +123,9 @@ template <typename T> TLogLevel& Log<T>::ReportingLevel()
template <typename T> std::string Log<T>::ToString(TLogLevel level) template <typename T> std::string Log<T>::ToString(TLogLevel level)
{ {
static const char* const buffer[] = {"ERROR", "WARNING", "INFO", "DEBUG", "DEBUG1", "DEBUG2", "DEBUG3", "DEBUG4","DEBUG5"}; static const char* const buffer[] = {
"ERROR", "WARNING", "INFO", "INFO", "INFO", "INFO",
"DEBUG", "DEBUG1", "DEBUG2", "DEBUG3", "DEBUG4","DEBUG5"};
return buffer[level]; return buffer[level];
} }
@ -211,21 +180,10 @@ inline void Output2FILE::Output(const std::string& msg, TLogLevel level)
case logERROR: cprintf(RED BOLD,"%s",msg.c_str()); break; case logERROR: cprintf(RED BOLD,"%s",msg.c_str()); break;
case logWARNING: cprintf(YELLOW BOLD,"%s",msg.c_str()); break; case logWARNING: cprintf(YELLOW BOLD,"%s",msg.c_str()); break;
case logINFO: cprintf(RESET,"%s",msg.c_str()); break; case logINFO: cprintf(RESET,"%s",msg.c_str()); break;
case logINFOBLUE: cprintf(BLUE,"%s",msg.c_str()); break;
case logINFORED: cprintf(RED,"%s",msg.c_str()); break;
case logINFOGREEN: cprintf(GREEN,"%s",msg.c_str()); break;
default: fprintf(pStream,"%s",msg.c_str()); out = false; break; default: fprintf(pStream,"%s",msg.c_str()); out = false; break;
} }
fflush(out ? stdout : pStream); fflush(out ? stdout : pStream);
} }
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
# if defined (BUILDING_FILELOG_DLL)
# define FILELOG_DECLSPEC __declspec (dllexport)
# elif defined (USING_FILELOG_DLL)
# define FILELOG_DECLSPEC __declspec (dllimport)
# else
# define FILELOG_DECLSPEC
# endif // BUILDING_DBSIMPLE_DLL
#else
# define FILELOG_DECLSPEC
#endif // _WIN32