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

added black background for reciever to see gray font better

Browse Source
This commit is contained in:
Dhanya Maliakal 2017-06-30 12:19:27 +02:00
parent 4b9a8c1dad
commit a4c07ba9a0
29 changed files with 337 additions and 957 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
slsReceiverSoftware/Makefile
View File

@ -1,6 +1,7 @@
include ../Makefile.include include ../Makefile.include
DESTDIR ?= ../bin DESTDIR ?= ../bin
LIBDIR ?= ../bin
DOCDIR ?= docs DOCDIR ?= docs
SRCDIR = src SRCDIR = src
INCDIR = include INCDIR = include
@ -22,7 +23,7 @@ INCLUDES?= $(INCLUDESRXR) -I include/ -I ../slsDetectorCalibration
LIBZMQDIR = include LIBZMQDIR = include
LIBZMQ = -L$(LIBZMQDIR) -Wl,-rpath=$(LIBZMQDIR) -lzmq LIBZMQ = -L$(LIBZMQDIR) -Wl,-rpath=$(LIBZMQDIR) -lzmq
#-Iinclude -I../slsDetectorCalibration -I$(ASM)
SRC_CLNT = MySocketTCP.cpp ThreadObject.cpp Listener.cpp DataProcessor.cpp DataStreamer.cpp Fifo.cpp File.cpp BinaryFile.cpp UDPInterface.cpp UDPBaseImplementation.cpp UDPStandardImplementation.cpp slsReceiverTCPIPInterface.cpp slsReceiver.cpp slsReceiverUsers.cpp utilities.cpp SRC_CLNT = MySocketTCP.cpp ThreadObject.cpp Listener.cpp DataProcessor.cpp DataStreamer.cpp Fifo.cpp File.cpp BinaryFile.cpp UDPInterface.cpp UDPBaseImplementation.cpp UDPStandardImplementation.cpp slsReceiverTCPIPInterface.cpp slsReceiver.cpp slsReceiverUsers.cpp utilities.cpp
DEPSINCLUDES = $(INCDIR)/ansi.h $(INCDIR)/sls_receiver_defs.h $(INCDIR)/sls_receiver_funcs.h $(INCDIR)/GeneralData.h $(INCDIR)/circularFifo.h $(INCDIR)/genericSocket.h $(INCDIR)/logger.h $(INCDIR)/receiver_defs.h $(INCDIR)/UDPInterface.h $(INCDIR)/utilities.h $(INCDIR)/ZmqSocket.h $(INCDIR)/BinaryFileStatic.h $(INCDIR)/HDF5FileStatic.h DEPSINCLUDES = $(INCDIR)/ansi.h $(INCDIR)/sls_receiver_defs.h $(INCDIR)/sls_receiver_funcs.h $(INCDIR)/GeneralData.h $(INCDIR)/circularFifo.h $(INCDIR)/genericSocket.h $(INCDIR)/logger.h $(INCDIR)/receiver_defs.h $(INCDIR)/UDPInterface.h $(INCDIR)/utilities.h $(INCDIR)/ZmqSocket.h $(INCDIR)/BinaryFileStatic.h $(INCDIR)/HDF5FileStatic.h
@ -38,7 +39,6 @@ endif
MAIN_SRC = main.cpp MAIN_SRC = main.cpp
DUMMY_MAIN_SRC = dummyMain.cpp
OBJS=$(SRC_CLNT:%.cpp=$(BUILDDIR)/%.o) OBJS=$(SRC_CLNT:%.cpp=$(BUILDDIR)/%.o)
@ -90,7 +90,7 @@ $(DESTDIR)/slsReceiver: $(SRCDIR)/$(MAIN_SRC) $(DESTDIR)/libSlsReceiver.so $(D
$(call colorecho,"#######################################") $(call colorecho,"#######################################")
$(call colorecho,"# Compiling slsReceiver #") $(call colorecho,"# Compiling slsReceiver #")
$(call colorecho,"#######################################") $(call colorecho,"#######################################")
$(CXX) -o $@ $(SRCDIR)/$(MAIN_SRC) $(FLAGS) $(INCLUDES) $(CLAGS) $(LIBS) $(LDFLAGRXR) -fPIC $(LIBZMQ) -lrt $(CXX) -o $@ $(SRCDIR)/$(MAIN_SRC) $(FLAGS) $(INCLUDES) $(CFLAGS) $(LIBS) $(LDFLAGRXR) -fPIC $(LIBZMQ) -lrt
#$(EIGERFLAGS) #$(EIGERFLAGS)
@ -98,17 +98,10 @@ $(DESTDIR)/dummyReceiver: $(SRCDIR)/$(DUMMY_MAIN_SRC) $(DESTDIR)/libSlsReceiver
$(call colorecho,"#######################################") $(call colorecho,"#######################################")
$(call colorecho,"# Compiling Dummy slsReceiver #") $(call colorecho,"# Compiling Dummy slsReceiver #")
$(call colorecho,"#######################################") $(call colorecho,"#######################################")
$(CXX) -o $@ $(SRCDIR)/$(DUMMY_MAIN_SRC) $(FLAGS) $(INCLUDES) $(CLAGS) $(LIBS) $(LDFLAGRXR) -fPIC $(LIBZMQ) -lrt $(CXX) -o $@ $(SRCDIR)/$(DUMMY_MAIN_SRC) $(FLAGS) $(INCLUDES) $(CFLAGS) $(LIBS) $(LDFLAGRXR) -fPIC $(LIBZMQ) -lrt
#$(EIGERFLAGS) #$(EIGERFLAGS)
# Stand-alone Mysocket tests
mysocket_test:
g++ -o $(TESTDIR)/MySocketTCP.o -c $(SRCDIR)/MySocketTCP.cpp -I include
g++ -o $(TESTDIR)/rec $(TESTDIR)/MySocketTCP.o $(TESTDIR)/rec.cxx -I include
g++ -o $(TESTDIR)/send $(TESTDIR)/MySocketTCP.o $(TESTDIR)/send.cxx -I include
clean: buildclean clean: buildclean
make testclean make testclean
if test -e $(DESTDIR)/libSlsReceiver.a; then rm $(DESTDIR)/libSlsReceiver.a;fi if test -e $(DESTDIR)/libSlsReceiver.a; then rm $(DESTDIR)/libSlsReceiver.a;fi

8
slsReceiverSoftware/gitInfo.txt
View File

@ -1,9 +1,9 @@
Path: slsDetectorsPackage/slsReceiverSoftware Path: slsDetectorsPackage/slsReceiverSoftware
URL: origin git@git.psi.ch:sls_detectors_software/sls_receiver_software.git URL: origin git@git.psi.ch:sls_detectors_software/sls_receiver_software.git
Repository Root: origin git@git.psi.ch:sls_detectors_software/sls_receiver_software.git Repository Root: origin git@git.psi.ch:sls_detectors_software/sls_receiver_software.git
Repsitory UUID: 7d45ac53d7d92a4817002e7aed7297d5ddfd0f73 Repsitory UUID: edef347a62cd0239115c76101154d94814c6916b
Revision: 596 Revision: 597
Branch: developer Branch: developer
Last Changed Author: Dhanya_Maliakal Last Changed Author: Dhanya_Maliakal
Last Changed Rev: 601 Last Changed Rev: 602
Last Changed Date: 2017-06-28 18:18:30 +0200 Last Changed Date: 2017-06-29 17:10:28 +0200

6
slsReceiverSoftware/include/BinaryFileStatic.h
View File

@ -117,12 +117,12 @@ 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 %s\n",fname.c_str()); bprintf(RED,"Error in creating binary master file %s\n",fname.c_str());
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 %s\n",fname.c_str()); bprintf(RED,"Error in creating binary master file %s\n",fname.c_str());
fd = 0; fd = 0;
return 1; return 1;
} }
@ -166,7 +166,7 @@ class BinaryFileStatic {
(long long int)acquisitionPeriod, (long long int)acquisitionPeriod,
ctime(&t)); ctime(&t));
if (strlen(message) > MAX_STR_LENGTH) { if (strlen(message) > MAX_STR_LENGTH) {
cprintf(BG_RED,"Master File Size %d is greater than max str size %d\n", bprintf(BG_RED,"Master File Size %d is greater than max str size %d\n",
(int)strlen(message), MAX_STR_LENGTH); (int)strlen(message), MAX_STR_LENGTH);
return 1; return 1;
} }

14
slsReceiverSoftware/include/File.h
View File

@ -107,7 +107,7 @@ class File : private virtual slsReceiverDefs {
* @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 overloaded by a derived class\n"); bprintf(RED,"This is a generic function CreateFile that should be overloaded by a derived class\n");
return OK; return OK;
} }
@ -115,14 +115,14 @@ class File : private virtual slsReceiverDefs {
* Close Current File * Close Current File
*/ */
virtual void CloseCurrentFile() { virtual void CloseCurrentFile() {
cprintf(RED,"This is a generic function CloseCurrentFile that should be overloaded by a derived class\n"); bprintf(RED,"This is a generic function CloseCurrentFile that should be overloaded by a derived class\n");
} }
/** /**
* Close Files * Close Files
*/ */
virtual void CloseAllFiles() { virtual void CloseAllFiles() {
cprintf(RED,"This is a generic function that should be overloaded by a derived class\n"); bprintf(RED,"This is a generic function that should be overloaded by a derived class\n");
} }
/** /**
@ -133,7 +133,7 @@ class File : private virtual slsReceiverDefs {
* @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 should be overloaded by a derived class\n"); bprintf(RED,"This is a generic function WriteToFile that should be overloaded by a derived class\n");
return FAIL; return FAIL;
} }
@ -149,7 +149,7 @@ class File : private virtual slsReceiverDefs {
*/ */
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 ap) { uint32_t nx, uint32_t ny, uint64_t at, uint64_t ap) {
cprintf(RED,"This is a generic function CreateMasterFile that should be overloaded by a derived class\n"); bprintf(RED,"This is a generic function CreateMasterFile that should be overloaded by a derived class\n");
return OK; return OK;
} }
@ -160,7 +160,7 @@ class File : private virtual slsReceiverDefs {
* @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 should be overloaded by a derived class\n"); bprintf(RED,"This is a generic function SetNumberofPixels that should be overloaded by a derived class\n");
} }
/** /**
@ -168,7 +168,7 @@ class File : private virtual slsReceiverDefs {
* @param numf number of images caught * @param numf number of images caught
*/ */
virtual void EndofAcquisition(uint64_t numf) { virtual void EndofAcquisition(uint64_t numf) {
cprintf(RED,"This is a generic function EndofAcquisition that should be overloaded by a derived class\n"); bprintf(RED,"This is a generic function EndofAcquisition that should be overloaded by a derived class\n");
} }
protected: protected:

75
slsReceiverSoftware/include/GeneralData.h
View File

@ -151,7 +151,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"); bprintf(RED,"This is a generic function that should be overloaded by a derived class\n");
}; };
/** /**
@ -160,58 +160,35 @@ 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"); bprintf(RED,"This is a generic function that should be overloaded by a derived class\n");
}; };
/** /**
* Print all variables * Print all variables
*/ */
virtual void Print() const { virtual void Print() const {
std::string temp = slsReceiverDefs::getDetectorType(myDetectorType); FILE_LOG(logDEBUG) << "\n\nDetector Data Variables:";
printf("\n\nDetector Data Variables:\n"); FILE_LOG(logDEBUG) << "myDetectorType: " << slsReceiverDefs::getDetectorType(myDetectorType);
printf( "myDetectorType:%s\n" FILE_LOG(logDEBUG) << "Pixels X: " << nPixelsX;
"Pixels X: %u\n" FILE_LOG(logDEBUG) << "Pixels Y: " << nPixelsY;
"Pixels Y: %u\n" FILE_LOG(logDEBUG) << "Empty Header: " << emptyHeader;
"Empty Header: %u\n" FILE_LOG(logDEBUG) << "Header Size in Packet: " << headerSizeinPacket;
"Header Size in Packet: %u\n" FILE_LOG(logDEBUG) << "Data Size: " << dataSize;
"Data Size: %u\n" FILE_LOG(logDEBUG) << "Packet Size: " << packetSize;
"Packet Size: %u\n" FILE_LOG(logDEBUG) << "Packets per Frame: " << packetsPerFrame;
"Packets per Frame: %u\n" FILE_LOG(logDEBUG) << "Image Size: " << imageSize;
"Image Size: %u\n" FILE_LOG(logDEBUG) << "Frame Index Mask: " << frameIndexMask;
"Frame Index Mask: 0x%llx\n" FILE_LOG(logDEBUG) << "Frame Index Offset: " << frameIndexOffset;
"Frame Index Offset: %u\n" FILE_LOG(logDEBUG) << "Packet Index Mask: " << packetIndexMask;
"Packet Index Mask: 0x%x\n" FILE_LOG(logDEBUG) << "Packet Index Offset: " << packetIndexOffset;
"Packet Index Offset: %u\n" FILE_LOG(logDEBUG) << "Max Frames Per File: " << maxFramesPerFile;
"Max Frames Per File: %u\n" FILE_LOG(logDEBUG) << "Fifo Buffer Header Size: " << fifoBufferHeaderSize;
"Fifo Buffer Header Size: %u\n" FILE_LOG(logDEBUG) << "Default Fifo Depth: " << defaultFifoDepth;
"Default Fifo Depth: %u\n" FILE_LOG(logDEBUG) << "Threads Per Receiver: " << threadsPerReceiver;
"Threads Per Receiver: %u\n" FILE_LOG(logDEBUG) << "Header Packet Size: " << headerPacketSize;
"Header Packet Size: %u\n" FILE_LOG(logDEBUG) << "Streamer Pixels X: " << nPixelsX_Streamer;
"Streamer Pixels X: %u\n" FILE_LOG(logDEBUG) << "Streamer Pixels Y: " << nPixelsY_Streamer;
"Streamer Pixels Y: %u\n" FILE_LOG(logDEBUG) << "Streamer Image Size: " << imageSize_Streamer;
"Streamer Image Size: %u\n"
,temp.c_str(),//.c_str() modifies, using temp string for thread safety
nPixelsX,
nPixelsY,
emptyHeader,
headerSizeinPacket,
dataSize,
packetSize,
packetsPerFrame,
imageSize,
(long long int)frameIndexMask,
frameIndexOffset,
packetIndexMask,
packetIndexOffset,
maxFramesPerFile,
fifoBufferHeaderSize,
defaultFifoDepth,
threadsPerReceiver,
headerPacketSize,
nPixelsX_Streamer,
nPixelsY_Streamer,
imageSize_Streamer);
}; };
}; };
@ -365,7 +342,7 @@ class Moench02Data : public GeneralData {
*/ */
void Print() const { void Print() const {
GeneralData::Print(); GeneralData::Print();
printf("Bytes Per Adc: %d\n",bytesPerAdc); FILE_LOG(logINFO) << "Bytes Per Adc: " << bytesPerAdc;
} }
}; };
@ -427,7 +404,7 @@ class JCTBData : public GeneralData {
*/ */
void Print() const { void Print() const {
GeneralData::Print(); GeneralData::Print();
printf("Bytes Per Adc: %d\n",bytesPerAdc); FILE_LOG(logINFO) << "Bytes Per Adc: " << bytesPerAdc;
} }
}; };

69
slsReceiverSoftware/include/HDF5FileStatic.h
View File

@ -110,7 +110,7 @@ public:
fd = 0; fd = 0;
} }
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in closing HDF5 handles of index %d\n", ind); bprintf(RED,"Error in closing HDF5 handles of index %d\n", ind);
error.printError(); error.printError();
} }
} }
@ -128,7 +128,7 @@ public:
fd = 0; fd = 0;
} }
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in closing master HDF5 handles\n"); bprintf(RED,"Error in closing master HDF5 handles\n");
error.printError(); error.printError();
} }
} }
@ -142,7 +142,7 @@ public:
{ {
if(fd) { if(fd) {
if (H5Fclose(fd) < 0 ) if (H5Fclose(fd) < 0 )
cprintf(RED,"Error in closing virtual HDF5 handles\n"); bprintf(RED,"Error in closing virtual HDF5 handles\n");
fd = 0; fd = 0;
} }
} }
@ -175,7 +175,7 @@ public:
memspace.close(); memspace.close();
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in writing to file in object %d\n",ind); bprintf(RED,"Error in writing to file in object %d\n",ind);
error.printError(); error.printError();
return 1; return 1;
} }
@ -211,7 +211,7 @@ public:
dset_para[12]->write(&header->version, ParameterDataTypes[12], memspace, *dspace_para); dset_para[12]->write(&header->version, ParameterDataTypes[12], memspace, *dspace_para);
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in writing parameters to file in object %d\n",ind); bprintf(RED,"Error in writing parameters to file in object %d\n",ind);
error.printError(); error.printError();
return 1; return 1;
} }
@ -319,7 +319,7 @@ public:
fd->close(); fd->close();
} catch(Exception error) { } catch(Exception error) {
cprintf(RED,"Error in creating master HDF5 handles\n"); bprintf(RED,"Error in creating master HDF5 handles\n");
error.printError(); error.printError();
return 1; return 1;
} }
@ -403,7 +403,7 @@ public:
dset_para[i] = new DataSet(fd->createDataSet(ParameterNames[i], ParameterDataTypes[i], *dspace_para)); dset_para[i] = new DataSet(fd->createDataSet(ParameterNames[i], ParameterDataTypes[i], *dspace_para));
} }
catch(Exception error){ catch(Exception error){
cprintf(RED,"Error in creating HDF5 handles in object %d\n",ind); bprintf(RED,"Error in creating HDF5 handles in object %d\n",ind);
error.printError(); error.printError();
fd->close(); fd->close();
return 1; return 1;
@ -449,7 +449,7 @@ public:
{ {
//virtual names //virtual names
string virtualFileName = CreateVirtualFileName(fpath, fnameprefix, findex); string virtualFileName = CreateVirtualFileName(fpath, fnameprefix, findex);
printf("Virtual File: %s\n", virtualFileName.c_str()); FILE_LOG(logINFO) << "Virtual File: " << virtualFileName;
//file //file
hid_t dfal = H5Pcreate (H5P_FILE_ACCESS); hid_t dfal = H5Pcreate (H5P_FILE_ACCESS);
@ -519,12 +519,12 @@ 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"); bprintf(RED,"could not select hyperslab\n");
error = true; error = true;
break; break;
} }
if (H5Sselect_hyperslab (vdsDataspace_para, H5S_SELECT_SET, offset_para, NULL, count_para, NULL) < 0) { if (H5Sselect_hyperslab (vdsDataspace_para, H5S_SELECT_SET, offset_para, NULL, count_para, NULL) < 0) {
cprintf(RED,"could not select hyperslab for parameters\n"); bprintf(RED,"could not select hyperslab for parameters\n");
error = true; error = true;
break; break;
} }
@ -551,14 +551,14 @@ public:
//mapping //mapping
if (H5Pset_virtual(dcpl, vdsDataspace, srcFileName.c_str(), srcDatasetName.c_str(), srcDataspace) < 0) { if (H5Pset_virtual(dcpl, vdsDataspace, srcFileName.c_str(), srcDatasetName.c_str(), srcDataspace) < 0) {
cprintf(RED,"could not set mapping for paramter 1\n"); bprintf(RED,"could not set mapping for paramter 1\n");
error = true; error = true;
break; break;
} }
for (int k = 0; k < NumberofParameters; ++k) { for (int k = 0; k < NumberofParameters; ++k) {
if (H5Pset_virtual(dcpl_para[k], vdsDataspace_para, srcFileName.c_str(), ParameterNames[k], srcDataspace_para) < 0) { if (H5Pset_virtual(dcpl_para[k], vdsDataspace_para, srcFileName.c_str(), ParameterNames[k], srcDataspace_para) < 0) {
cprintf(RED,"could not set mapping for paramter %d\n", k); bprintf(RED,"could not set mapping for paramter %d\n", k);
error = true; error = true;
break; break;
} }
@ -631,39 +631,30 @@ 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"); bprintf(RED,"invalid rank. Options: 2 or 3\n");
return 0; return 0;
} }
if (datatype == PredType::STD_U16LE) { if (datatype == PredType::STD_U16LE) {
printf("datatype:16\n"); FILE_LOG(logINFO) << "datatype:16";
} else if (datatype == PredType::STD_U32LE) { } else if (datatype == PredType::STD_U32LE) {
printf("datatype:32\n"); FILE_LOG(logINFO) << "datatype:32";
} else if (datatype == PredType::STD_U64LE) { } else if (datatype == PredType::STD_U64LE) {
printf("datatype:64\n"); FILE_LOG(logINFO) << "datatype:64";
} else if (datatype == PredType::STD_U8LE) { } else if (datatype == PredType::STD_U8LE) {
printf("datatype:8\n"); FILE_LOG(logINFO) << "datatype:8";
} else { } else {
cprintf(RED, "unknown datatype\n"); FILE_LOG(logERROR) << "unknown datatype";
return 1; return 1;
} }
printf("owenable:%d\n" FILE_LOG(logINFO) << "owenable:" << owenable?1:0 << endl
"oldFileName:%s\n" << "oldFileName:" << oldFileName << endl
"oldDatasetName:%s\n" << "oldDatasetName:" << oldDatasetName << endl
"newFileName:%s\n" << "newFileName:" << newFileName << endl
"newDatasetName:%s\n" << "newDatasetName:" << newDatasetName << endl
"rank:%d\n" << "rank:" << rank << endl
"nDimx:%llu\n" << "nDimx:" << nDimx << endl
"nDimy:%u\n" << "nDimy:" << nDimy << endl
"nDimz:%u\n", << "nDimz:" << nDimz;
owenable?1:0,
oldFileName.c_str(),
oldDatasetName.c_str(),
newFileName.c_str(),
newDatasetName.c_str(),
rank,
(long long unsigned int)nDimx,
nDimy,
nDimz);
H5File* oldfd; H5File* oldfd;
H5File* newfd; H5File* newfd;
@ -697,7 +688,7 @@ public:
newfd->close(); newfd->close();
oldfd->close(); oldfd->close();
} catch(Exception error){ } catch(Exception error){
cprintf(RED,"Error in copying virtual files\n"); bprintf(RED,"Error in copying virtual files\n");
error.printError(); error.printError();
free(data_out); free(data_out);
oldfd->close(); oldfd->close();
@ -781,7 +772,7 @@ public:
* @returns 1 for fail * @returns 1 for fail
*/ */
static int CloseFileOnError(hid_t& fd, const string msg) { static int CloseFileOnError(hid_t& fd, const string msg) {
cprintf(RED, "%s", msg.c_str()); bprintf(RED, "%s", msg.c_str());
if(fd > 0) if(fd > 0)
H5Fclose(fd); H5Fclose(fd);
fd = 0; fd = 0;
@ -804,7 +795,7 @@ public:
else if (dtype == PredType::STD_U64LE) else if (dtype == PredType::STD_U64LE)
return H5T_STD_U64LE; return H5T_STD_U64LE;
else { else {
cprintf(RED, "Invalid Data type\n"); bprintf(RED, "Invalid Data type\n");
return H5T_STD_U64LE; return H5T_STD_U64LE;
} }
} }

2
slsReceiverSoftware/include/ZmqSocket.h
View File

@ -243,7 +243,7 @@ public:
detType, version); detType, version);
#ifdef VERBOSE #ifdef VERBOSE
//if(!index) //if(!index)
printf("%d Streamer: buf:%s\n", index, buf); FILE_LOG(logINFO) << index << ": Streamer: buf:" << buf;
#endif #endif
if(zmq_send (socketDescriptor, buf, length, dummy?0:ZMQ_SNDMORE) < 0) { if(zmq_send (socketDescriptor, buf, length, dummy?0:ZMQ_SNDMORE) < 0) {

6
slsReceiverSoftware/include/ansi.h
View File

@ -6,6 +6,8 @@
#define CYAN "\x1b[36m" #define CYAN "\x1b[36m"
#define GRAY "\x1b[37m" #define GRAY "\x1b[37m"
#define DARKGRAY "\x1b[30m" #define DARKGRAY "\x1b[30m"
#define BG_BLACK "\x1b[48;5;232m"
#define BG_RED "\x1b[41m" #define BG_RED "\x1b[41m"
#define BG_GREEN "\x1b[42m" #define BG_GREEN "\x1b[42m"
#define BG_YELLOW "\x1b[43m" #define BG_YELLOW "\x1b[43m"
@ -15,8 +17,10 @@
#define RESET "\x1b[0m" #define RESET "\x1b[0m"
#define BOLD "\x1b[1m" #define BOLD "\x1b[1m"
//on background black
#define bprintf(code, format, ...) printf(code BG_BLACK format RESET, ##__VA_ARGS__)
//normal printout
#define cprintf(code, format, ...) printf(code format RESET, ##__VA_ARGS__) #define cprintf(code, format, ...) printf(code format RESET, ##__VA_ARGS__)
/* /*
Code examples Code examples

11
slsReceiverSoftware/include/circularFifo.h
View File

@ -70,11 +70,8 @@ int CircularFifo<Element>::getSemValue()
template<typename Element> template<typename Element>
bool CircularFifo<Element>::push(Element*& item_) bool CircularFifo<Element>::push(Element*& item_)
{ {
//cout<<"*head:"<<head<<endl;
//cout<<"*tail before"<<tail<<endl;
unsigned int nextTail = increment(tail); unsigned int nextTail = increment(tail);
//cout<<"*next tail"<<nextTail<<endl;
if(nextTail != head) if(nextTail != head)
{ {
array[tail] = item_; array[tail] = item_;
@ -95,15 +92,11 @@ bool CircularFifo<Element>::push(Element*& item_)
template<typename Element> template<typename Element>
bool CircularFifo<Element>::pop(Element*& item_) bool CircularFifo<Element>::pop(Element*& item_)
{ {
//cout<<"-tail:"<<tail<<endl;
//cout<<"-head before:"<<head<<endl;
//if(head == tail)
// return false; // empty queue
sem_wait(&free_mutex); sem_wait(&free_mutex);
item_ = array[head]; item_ = array[head];
head = increment(head); head = increment(head);
//cout<<"-head after:"<<head<<endl;
return true; return true;
} }

434
slsReceiverSoftware/include/dummyUDPInterface.h
View File

@ -1,434 +0,0 @@
#pragma once
/***********************************************
* @file UDPInterface.h
* @short Base class with all the functions for the UDP inteface of the receiver
***********************************************/
/**
* \mainpage Base class with all the functions for the UDP inteface of the receiver
*/
/**
* @short Base class with all the functions for the UDP inteface of the receiver
*/
#include "UDPInterface.h"
#include "sls_receiver_defs.h"
#include "genericSocket.h"
class dummyUDPInterface : public UDPInterface {
/* abstract class that defines the UDP interface of an sls detector data receiver.
*
* Use the factory method UDPInterface::create() to get an instance:
*
* UDPInterface *udp_interface = UDPInterface::create()
*
* supported sequence of method-calls:
*
* initialize() : once and only once after create()
*
* get*() : anytime after initialize(), multiples times
* set*() : anytime after initialize(), multiple times
*
* startReceiver(): anytime after initialize(). Will fail if state already is 'running'
*
* abort(),
* stopReceiver() : anytime after initialize(). Will do nothing if state already is idle.
*
* getStatus() returns the actual state of the data receiver - running or idle. All other
* get*() and set*() methods access the local cache of configuration values only and *do not* modify the data receiver settings.
*
* Only startReceiver() does change the data receiver configuration, it does pass the whole configuration cache to the data receiver.
*
* get- and set-methods that return a char array (char *) allocate a new array at each call. The caller is responsible to free the allocated space:
*
* char *c = receiver->getFileName();
* ....
* delete[] c;
*
* always: 1:YES 0:NO for int as bool-like arguments
*
*/
public:
/**
* Destructor
*/
dummyUDPInterface() : UDPInterface(), dynamicRange(16), scanTag(1000), nFrames(100), fWrite(1), fOverwrite(1), fIndex(0), fCaught(0), totfCaught(0), startAcqIndex(0), startFrameIndex(0), acqIndex(0), dataCompression(false), period(0), type(slsReceiverDefs::GENERIC), framesNeeded(100), udpPort1(1900), udpPort2(1901), shortFrame(0), nFramesToGui(0), e10G(0) {strcpy(detHostname,"none"); strcpy(fName,"run"); strcpy(fPath,"/scratch/"); strcpy(eth,"eth0"); cout << "New dummy UDP Interface" << endl;
};
~dummyUDPInterface() {cout << "Destroying dummy UDP Interface" << endl;};
void del(){cout << "Destroying dummy UDP Interface" << endl;};
virtual void configure(map<string, string> config_map) {};
/**
* Initialize the Receiver
@param detectorHostName detector hostname
* you can call this function only once. You must call it before you call startReceiver() for the first time.
*/
virtual void initialize(const char *detectorHostName){ cout << "set detector hostname to" << detHostname << endl; strcpy(detHostname,detectorHostName);};
/* Returns detector hostname
/returns hostname
* caller needs to deallocate the returned char array.
* if uninitialized, it must return NULL
*/
virtual char *getDetectorHostname() const { cout << "get detector hostname " << detHostname << endl; return (char*) detHostname;};
/**
* Returns status of receiver: idle, running or error
*/
virtual slsReceiverDefs::runStatus getStatus() const { cout << "get dsummy status IDLE " << endl; return slsReceiverDefs::IDLE;};;
/**
* Returns File Name
* caller is responsible to deallocate the returned char array.
*/
virtual char *getFileName() const { cout << "get file name " << fName << endl; return (char*) fName;};
/**
* Returns File Path
* caller is responsible to deallocate the returned char array
*/
virtual char *getFilePath() const { cout << "get file path " << fPath << endl; return (char*) fPath;};;
/**
* Returns the number of bits per pixel
*/
virtual int getDynamicRange() const { cout << "get dynamic range " << dynamicRange << endl; return dynamicRange;};;
/**
* Returns scan tag
*/
virtual int getScanTag() const { cout << "get scan tag " << scanTag << endl; return scanTag;};
/*
* Returns number of frames to receive
* This is the number of frames to expect to receiver from the detector.
* The data receiver will change from running to idle when it got this number of frames
*/
virtual int getNumberOfFrames() const { cout << "get number of frames " << nFrames << endl; return nFrames;};
/**
* Returns file write enable
* 1: YES 0: NO
*/
virtual int getEnableFileWrite() const { cout << "get enable file write " << fWrite << endl; return fWrite;};
/**
* Returns file over write enable
* 1: YES 0: NO
*/
virtual int getEnableOverwrite() const { cout << "get enable file overwrite " << fOverwrite << endl; return fOverwrite;};
/**
* Set File Name (without frame index, file index and extension)
@param c file name
/returns file name
* returns NULL on failure (like bad file name)
* does not check the existence of the file - we don't know which path we'll finally use, so no point to check.
* caller is responsible to deallocate the returned char array.
*/
virtual char* setFileName(const char c[]) { strcpy(fName,c); cout << "set file name " << fName << endl; return fName; };
/**
* Set File Path
@param c file path
/returns file path
* checks the existence of the directory. returns NULL if directory does not exist or is not readable.
* caller is responsible to deallocate the returned char array.
*/
virtual char* setFilePath(const char c[]) { strcpy(fPath,c); cout << "set file path " << fPath << endl; return fPath; };
/**
* Returns the number of bits per pixel
@param dr sets dynamic range
/returns dynamic range
* returns -1 on failure
* FIXME: what are the allowd values - should we use an enum as argument?
*/
virtual int setDynamicRange(const int dr) {dynamicRange=dr; cout << "set dynamic range " << dynamicRange << endl; return dynamicRange; };
/**
* Set scan tag
@param tag scan tag
/returns scan tag (always non-negative)
* FIXME: valid range - only positive? 16bit ore 32bit?
* returns -1 on failure
*/
virtual int setScanTag(const int tag) {scanTag=tag; cout << "set scan tag " << scanTag << endl; return scanTag; };
/**
* Sets number of frames
@param fnum number of frames
/returns number of frames
*/
virtual int setNumberOfFrames(const int fnum) {nFrames=fnum; cout << "set number of frames " << nFrames << endl; return nFrames; };
/**
* Set enable file write
* @param i file write enable
/returns file write enable
*/
virtual int setEnableFileWrite(const int i) {fWrite=i; cout << "set enable file write " << fWrite << endl; return fWrite; };
/**
* Set enable file overwrite
* @param i file overwrite enable
/returns file overwrite enable
*/
virtual int setEnableOverwrite(const int i) {fOverwrite=i; cout << "set enable file overwrite " << fOverwrite << endl; return fOverwrite; };
/**
* Starts Receiver - activate all configuration settings to the eiger receiver and start to listen for packets
@param message is the error message if there is an error
/returns 0 on success or -1 on failure
*/
//FIXME: success == 0 or success == 1?
virtual int startReceiver(char *message=NULL) {cout << "dummy start receiver" << endl;
char buff[8225];
buff[8224]='\0';
int ip=0;
int ib;
genericSocket *udpSocket= new genericSocket(50004,genericSocket::UDP,8224);
while((ib=udpSocket->ReceiveDataOnly(buff,8224))>0) {
cout << "*** "<< ib <<" ************************** " << ip++ << endl;
cout << buff << endl;
cout << "*****************************" << endl << endl<< endl ;
}
return 0;};
/**
* Stops Receiver - stops listening for packets
/returns success
* same as abort(). Always returns 0.
*/
virtual int stopReceiver() {cout << "dummy stop receiver" << endl; return 0;};
/**
* abort acquisition with minimum damage: close open files, cleanup.
* does nothing if state already is 'idle'
*/
virtual void abort() {cout << "Aborting receiver" << endl; };
/*******************************************************************************************************************
**************************************** Added by Dhanya *********************************************************
*******************************************************************************************************************/
/**
* Returns File Index
*/
virtual int getFileIndex() {cout << "get file index " << fIndex << endl; return fIndex;};
/**
* Returns Total Frames Caught for an entire acquisition (including all scans)
*/
virtual int getTotalFramesCaught() {cout << "get total frames caught " << totfCaught << endl ; return totfCaught;};
/**
* Returns Frames Caught for each real time acquisition (eg. for each scan)
*/
virtual int getFramesCaught() {cout << "get frames caught " << fCaught << endl; return fCaught;};
/**
* Returns the frame index at start of entire acquisition (including all scans)
*/
virtual uint32_t getStartAcquisitionIndex(){ cout << "get start acquisition index " << startAcqIndex << endl; return startAcqIndex; };
/**
* Returns current Frame Index Caught for an entire acquisition (including all scans)
*/
virtual uint32_t getAcquisitionIndex(){ cout << "get acquisition index " << acqIndex << endl; return acqIndex; };
/**
* Returns the frame index at start of each real time acquisition (eg. for each scan)
*/
virtual uint32_t getStartFrameIndex() { cout << "get start frame index " << startFrameIndex << endl; return startFrameIndex; };
/** get data compression, by saving only hits
*/
virtual bool getDataCompression() { cout << "get data compression " << dataCompression << endl; return dataCompression;};
/**
* Set receiver type
* @param det detector type
* Returns success or FAIL
*/
virtual int setDetectorType(slsReceiverDefs::detectorType det) {type=det; cout << "set detector type " << det << endl; return slsReceiverDefs::OK;};
/**
* Set File Index
* @param i file index
*/
virtual int setFileIndex(int i) {fIndex=i; cout << "get file index " << fIndex << endl; return fIndex;};
/** set acquisition period if a positive number
*/
virtual int64_t setAcquisitionPeriod(int64_t index) {if (index>=0) {period=index; cout << "set period " << period << endl;} else { cout << "get period " << period << endl;} return period;};
/**
* Set Frame Index Needed
* @param i frame index needed
*/
virtual int setFrameIndexNeeded(int i) {framesNeeded=i; cout << "set frame index needed " << period << endl; return framesNeeded;};
/**
* Set UDP Port Number
*/
virtual void setUDPPortNo(int p){udpPort1=p; cout << "set UDP port 1 " << udpPort1 << endl; };
/**
* Set UDP Port Number
*/
virtual void setUDPPortNo2(int p) {udpPort2=p; cout << "set UDP port 2 " << udpPort2 << endl; };
/**
* Set Ethernet Interface or IP to listen to
*/
virtual void setEthernetInterface(char* c){strcpy(eth,c); cout << "set eth " << c;};
/**
* Set short frame
* @param i if shortframe i=1
*/
virtual int setShortFrame(int i){shortFrame=i; cout << " set short frame" << shortFrame << endl; return shortFrame;};
/**
* Set the variable to send every nth frame to gui
* or if 0,send frame only upon gui request
*/
virtual int setNFrameToGui(int i) {nFramesToGui=i; cout << "set nframes to gui " << nFramesToGui << endl; return nFramesToGui;};
/**
* Resets the Total Frames Caught
* This is how the receiver differentiates between entire acquisitions
* Returns 0
*/
virtual void resetTotalFramesCaught() {totfCaught=0; cout << "total frames caugh reset " << totfCaught << endl;};
/** enabl data compression, by saving only hits
/returns if failed
*/
virtual int enableDataCompression(bool enable) {dataCompression=enable; cout << "set data compression " << dataCompression<< endl; return dataCompression;};
/**
* enable 10Gbe
@param enable 1 for 10Gbe or 0 for 1 Gbe, -1 to read out
\returns enable for 10Gbe
*/
virtual int enableTenGiga(int enable = -1) {if (enable>=0) {e10G=enable; cout << "set 10Gb "<< e10G << endl;} else cout << "get 10Gb "<< e10G << endl; return e10G;};
/**
* Returns the buffer-current frame read by receiver
* @param c pointer to current file name
* @param raw address of pointer, pointing to current frame to send to gui
* @param fnum frame number for eiger as it is not in the packet
* @param startAcquisitionIndex is the start index of the acquisition
* @param startFrameIndex is the start index of the scan
*/
virtual void readFrame(char* c,char** raw, uint32_t &fnum, uint32_t &startAcquisitionIndex, uint32_t &startFrameIndex){cout << "dummy read frame" << endl; };
/** set status to transmitting and
* when fifo is empty later, sets status to run_finished
*/
virtual void startReadout(){cout << "dummy start readout" << endl; };
/**
* shuts down the udp sockets
* \returns if success or fail
*/
virtual int shutDownUDPSockets(){cout << "dummy shut down udp sockets" << endl; return slsReceiverDefs::OK;};
/**
* Closes all files
* @param ithr thread index, -1 for all threads
*/
virtual void closeFile(int ithr = -1){cout << "dummy close file" << ithr << endl; };
/**
* Call back for start acquisition
callback arguments are
filepath
filename
fileindex
datasize
return value is
0 callback takes care of open,close,wrie file
1 callback writes file, we have to open, close it
2 we open, close, write file, callback does not do anything
*/
virtual void registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg){cout << "dummy register callback start acquisition" << endl; };
/**
* Call back for acquisition finished
callback argument is
total frames caught
*/
virtual void registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg){cout << "dummy register callback acquisition finished" << endl; };
/**
* Call back for raw data
args to raw data ready callback are
framenum
datapointer
datasize in bytes
file descriptor
guidatapointer (NULL, no data required)
*/
virtual void registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg){cout << "dummy register callback get raw data" << endl; };
protected:
private:
char detHostname[1000];
char fName[10000];
char fPath[10000];
int dynamicRange;
int scanTag;
int nFrames;
int fWrite;
int fOverwrite;
int fIndex;
int fCaught;
int totfCaught;
int startAcqIndex;
int startFrameIndex;
int acqIndex;
bool dataCompression;
int64_t period;
slsReceiverDefs::detectorType type;
int framesNeeded;
int udpPort1;
int udpPort2;
char eth[1000];
int shortFrame;
int nFramesToGui;
int e10G;
};

9
slsReceiverSoftware/include/genericSocket.h
View File

@ -313,7 +313,7 @@ enum communicationProtocol{
/** @short etablishes connection; disconnect should always follow /** @short etablishes connection; disconnect should always follow
\returns 1 if error \returns 1 if error
*/ */
int Connect(){//cout<<"connect"<<endl; int Connect(){
if(file_des>0) return file_des; if(file_des>0) return file_des;
if (protocol==UDP) return -1; if (protocol==UDP) return -1;
@ -458,7 +458,6 @@ enum communicationProtocol{
if (ts<=0) if (ts<=0)
return -1; return -1;
//cout << "socketdescriptor "<< socketDescriptor << endl;
struct timeval tout; struct timeval tout;
tout.tv_sec = 0; tout.tv_sec = 0;
tout.tv_usec = 0; tout.tv_usec = 0;
@ -612,7 +611,7 @@ enum communicationProtocol{
continue; continue;
if(nsent != nsending){ if(nsent != nsending){
if(nsent && (nsent != -1)) if(nsent && (nsent != -1))
cprintf(RED,"Incomplete Packet size %d\n",nsent); bprintf(RED,"Incomplete Packet size %d\n",nsent);
break; break;
} }
length-=nsent; length-=nsent;
@ -625,7 +624,7 @@ enum communicationProtocol{
nsending=packet_size; nsending=packet_size;
while(1){ while(1){
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cprintf(BLUE,"%d gonna listen\n", portno); fflush(stdout); bprintf(BLUE,"%d gonna listen\n", portno); fflush(stdout);
#endif #endif
nsent = recvfrom(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length); nsent = recvfrom(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length);
//break out of loop only if read one packets size or read didnt work (cuz of shutdown) //break out of loop only if read one packets size or read didnt work (cuz of shutdown)
@ -633,7 +632,7 @@ enum communicationProtocol{
break; break;
//incomplete packets or header packets ignored and read buffer again //incomplete packets or header packets ignored and read buffer again
if(nsent != packet_size && nsent != header_packet_size) if(nsent != packet_size && nsent != header_packet_size)
cprintf(RED,"Incomplete Packet size %d\n",nsent); bprintf(RED,"Incomplete Packet size %d\n",nsent);
} }
//nsent = 1040; //nsent = 1040;
total_sent+=nsent; total_sent+=nsent;

8
slsReceiverSoftware/include/gitInfoReceiver.h
View File

@ -1,11 +1,11 @@
//#define SVNPATH "" //#define SVNPATH ""
#define SVNURL "git@git.psi.ch:sls_detectors_software/sls_receiver_software.git" #define SVNURL "git@git.psi.ch:sls_detectors_software/sls_receiver_software.git"
//#define SVNREPPATH "" //#define SVNREPPATH ""
#define SVNREPUUID "7d45ac53d7d92a4817002e7aed7297d5ddfd0f73" #define SVNREPUUID "edef347a62cd0239115c76101154d94814c6916b"
//#define SVNREV 0x601 //#define SVNREV 0x602
//#define SVNKIND "" //#define SVNKIND ""
//#define SVNSCHED "" //#define SVNSCHED ""
#define SVNAUTH "Dhanya_Maliakal" #define SVNAUTH "Dhanya_Maliakal"
#define SVNREV 0x601 #define SVNREV 0x602
#define SVNDATE 0x20170628 #define SVNDATE 0x20170629
// //

15
slsReceiverSoftware/include/logger.h
View File

@ -32,13 +32,8 @@
) )
#define __SHORT_AT__ string(__SHORT_FORM_OF_FILE__) + string("::") + string(__func__) + string("(): ") #define __SHORT_AT__ string(__SHORT_FORM_OF_FILE__) + string("::") + string(__func__) + string("(): ")
//":" TOSTRING(__LINE__)
/*
void error(const char *location, const char *msg){
printf("Error at %s: %s\n", location, msg);
}
*/
inline std::string NowTime(); inline std::string NowTime();
@ -223,10 +218,10 @@ inline void Output2FILE::Output(const std::string& msg, TLogLevel level)
return; return;
bool out = true; bool out = true;
switch(level){ switch(level){
case logERROR: cprintf(RED BOLD,"%s",msg.c_str()); break; case logERROR: bprintf(RED BOLD,"%s",msg.c_str()); break;
case logWARNING: cprintf(YELLOW BOLD,"%s",msg.c_str()); break; case logWARNING: bprintf(YELLOW BOLD,"%s",msg.c_str()); break;
case logINFO: cprintf(GRAY,"%s",msg.c_str()); break; case logINFO: bprintf(GRAY,"%s",msg.c_str()); break;
// case logINFO: cprintf(DARKGRAY BOLD,"%s",msg.c_str());break; // case logINFO: bprintf(DARKGRAY BOLD,"%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);

14
slsReceiverSoftware/src/BinaryFile.cpp
View File

@ -35,8 +35,8 @@ BinaryFile::~BinaryFile() {
void BinaryFile::PrintMembers() { void BinaryFile::PrintMembers() {
File::PrintMembers(); File::PrintMembers();
printf("Max Frames Per File: %d\n",maxFramesPerFile); FILE_LOG(logINFO) << "Max Frames Per File: " << maxFramesPerFile;
printf("Number of Frames in File: %d\n",numFramesInFile); FILE_LOG(logINFO) << "Number of Frames in File: " << numFramesInFile;
} }
slsReceiverDefs::fileFormat BinaryFile::GetFileType() { slsReceiverDefs::fileFormat BinaryFile::GetFileType() {
@ -61,14 +61,14 @@ int BinaryFile::CreateFile(uint64_t fnum) {
//first file, print entrire path //first file, print entrire path
if (loss == -1) if (loss == -1)
printf("[%u]: Binary File created: %s\n", *udpPortNumber, currentFileName.c_str()); FILE_LOG(logINFO) << "[" << *udpPortNumber << "]: Binary File created: " << currentFileName;
//other files //other files
else { else {
if (loss) if (loss)
cprintf(RED,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n", bprintf(RED,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n",
*udpPortNumber,loss, fifo->GetMaxLevelForFifoBound() , basename(currentFileName.c_str())); *udpPortNumber,loss, fifo->GetMaxLevelForFifoBound() , basename(currentFileName.c_str()));
else else
cprintf(GREEN,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n", bprintf(GREEN,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n",
*udpPortNumber,loss, fifo->GetMaxLevelForFifoBound(), basename(currentFileName.c_str())); *udpPortNumber,loss, fifo->GetMaxLevelForFifoBound(), basename(currentFileName.c_str()));
} }
@ -94,7 +94,7 @@ int BinaryFile::WriteToFile(char* buffer, int buffersize, uint64_t fnum, uint32_
numActualPacketsInFile += nump; numActualPacketsInFile += nump;
if (BinaryFileStatic::WriteDataFile(filefd, buffer, buffersize, fnum) == buffersize) if (BinaryFileStatic::WriteDataFile(filefd, buffer, buffersize, fnum) == buffersize)
return OK; return OK;
cprintf(RED,"%d Error: Write to file failed for image number %lld\n", index, (long long int)fnum); bprintf(RED,"%d Error: Write to file failed for image number %lld\n", index, (long long int)fnum);
return FAIL; return FAIL;
} }
@ -107,7 +107,7 @@ int BinaryFile::CreateMasterFile(bool en, uint32_t size,
if (master && (*detIndex==0)) { if (master && (*detIndex==0)) {
masterFileName = BinaryFileStatic::CreateMasterFileName(filePath, fileNamePrefix, *fileIndex); masterFileName = BinaryFileStatic::CreateMasterFileName(filePath, fileNamePrefix, *fileIndex);
printf("Master File: %s\n", masterFileName.c_str()); FILE_LOG(logINFO) << "Master File: " << masterFileName;
return BinaryFileStatic::CreateMasterDataFile(masterfd, masterFileName, *overWriteEnable, return BinaryFileStatic::CreateMasterDataFile(masterfd, masterFileName, *overWriteEnable,
*dynamicRange, en, size, nx, ny, *numImages, *dynamicRange, en, size, nx, ny, *numImages,
at, ap, BINARY_WRITER_VERSION); at, ap, BINARY_WRITER_VERSION);

14
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -168,7 +168,7 @@ void DataProcessor::RecordFirstIndices(uint64_t fnum) {
} }
#ifdef VERBOSE #ifdef VERBOSE
cprintf(BLUE,"%d First Acquisition Index:%lld\tFirst Measurement Index:%lld\n", bprintf(BLUE,"%d First Acquisition Index:%lld\tFirst Measurement Index:%lld\n",
index, (long long int)firstAcquisitionIndex, (long long int)firstMeasurementIndex); index, (long long int)firstAcquisitionIndex, (long long int)firstMeasurementIndex);
#endif #endif
} }
@ -270,13 +270,13 @@ void DataProcessor::ThreadExecution() {
char* buffer=0; char* buffer=0;
fifo->PopAddress(buffer); fifo->PopAddress(buffer);
#ifdef FIFODEBUG #ifdef FIFODEBUG
if (!index) cprintf(BLUE,"DataProcessor %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer); if (!index) bprintf(BLUE,"DataProcessor %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer);
#endif #endif
//check dummy //check dummy
uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer)); uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer));
#ifdef VERBOSE #ifdef VERBOSE
if (!index) cprintf(BLUE,"DataProcessor %d, Numbytes:%u\n", index,numBytes); if (!index) bprintf(BLUE,"DataProcessor %d, Numbytes:%u\n", index,numBytes);
#endif #endif
if (numBytes == DUMMY_PACKET_VALUE) { if (numBytes == DUMMY_PACKET_VALUE) {
StopProcessing(buffer); StopProcessing(buffer);
@ -297,7 +297,7 @@ void DataProcessor::ThreadExecution() {
void DataProcessor::StopProcessing(char* buf) { void DataProcessor::StopProcessing(char* buf) {
#ifdef VERBOSE #ifdef VERBOSE
if (!index) if (!index)
cprintf(RED,"DataProcessing %d: Dummy\n", index); bprintf(RED,"DataProcessing %d: Dummy\n", index);
#endif #endif
//stream or free //stream or free
if (*dataStreamEnable) if (*dataStreamEnable)
@ -308,7 +308,7 @@ void DataProcessor::StopProcessing(char* buf) {
file->CloseCurrentFile(); file->CloseCurrentFile();
StopRunning(); StopRunning();
#ifdef VERBOSE #ifdef VERBOSE
printf("%d: Processing Completed\n", index); FILE_LOG(logINFO) << index << ": Processing Completed";
#endif #endif
} }
@ -326,12 +326,12 @@ void DataProcessor::ProcessAnImage(char* buf) {
#ifdef VERBOSE #ifdef VERBOSE
if (!index) if (!index)
cprintf(BLUE,"DataProcessing %d: fnum:%lu\n", index, fnum); bprintf(BLUE,"DataProcessing %d: fnum:%lu\n", index, fnum);
#endif #endif
if (!measurementStartedFlag) { if (!measurementStartedFlag) {
#ifdef VERBOSE #ifdef VERBOSE
if (!index) cprintf(BLUE,"DataProcessing %d: fnum:%lu\n", index, fnum); if (!index) bprintf(BLUE,"DataProcessing %d: fnum:%lu\n", index, fnum);
#endif #endif
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
} }

28
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -135,7 +135,7 @@ void DataStreamer::RecordFirstIndices(uint64_t fnum) {
} }
#ifdef VERBOSE #ifdef VERBOSE
cprintf(BLUE,"%d First Acquisition Index:%lld\tFirst Measurement Index:%lld\n", bprintf(BLUE,"%d First Acquisition Index:%lld\tFirst Measurement Index:%lld\n",
index, (long long int)firstAcquisitionIndex, (long long int)firstMeasurementIndex); index, (long long int)firstAcquisitionIndex, (long long int)firstMeasurementIndex);
#endif #endif
} }
@ -166,10 +166,10 @@ int DataStreamer::CreateZmqSockets(int* dindex, int* nunits) {
zmqSocket = new ZmqSocket(portnum); zmqSocket = new ZmqSocket(portnum);
if (zmqSocket->IsError()) { if (zmqSocket->IsError()) {
cprintf(RED, "Error: Could not create Zmq socket on port %d for Streamer %d\n", portnum, index); bprintf(RED, "Error: Could not create Zmq socket on port %d for Streamer %d\n", portnum, index);
return FAIL; return FAIL;
} }
printf("%d Streamer: Zmq Server started at %s\n",index, zmqSocket->GetZmqServerAddress()); FILE_LOG(logINFO) << index << " Streamer: Zmq Server started at " << zmqSocket->GetZmqServerAddress();
return OK; return OK;
} }
@ -186,13 +186,13 @@ void DataStreamer::ThreadExecution() {
char* buffer=0; char* buffer=0;
fifo->PopAddressToStream(buffer); fifo->PopAddressToStream(buffer);
#ifdef FIFODEBUG #ifdef FIFODEBUG
if (!index) cprintf(BLUE,"DataStreamer %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer); if (!index) bprintf(BLUE,"DataStreamer %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer);
#endif #endif
//check dummy //check dummy
uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer)); uint32_t numBytes = (uint32_t)(*((uint32_t*)buffer));
#ifdef VERBOSE #ifdef VERBOSE
cprintf(GREEN,"DataStreamer %d, Numbytes:%u\n", index,numBytes); bprintf(GREEN,"DataStreamer %d, Numbytes:%u\n", index,numBytes);
#endif #endif
if (numBytes == DUMMY_PACKET_VALUE) { if (numBytes == DUMMY_PACKET_VALUE) {
StopProcessing(buffer); StopProcessing(buffer);
@ -211,17 +211,17 @@ void DataStreamer::ThreadExecution() {
void DataStreamer::StopProcessing(char* buf) { void DataStreamer::StopProcessing(char* buf) {
#ifdef VERBOSE #ifdef VERBOSE
if (!index) if (!index)
cprintf(RED,"DataStreamer %d: Dummy\n", index); bprintf(RED,"DataStreamer %d: Dummy\n", index);
#endif #endif
sls_detector_header* header = (sls_detector_header*) (buf); sls_detector_header* header = (sls_detector_header*) (buf);
//send dummy header and data //send dummy header and data
if (!SendHeader(header, true)) if (!SendHeader(header, true))
cprintf(RED,"Error: Could not send zmq dummy header for streamer %d\n", index); bprintf(RED,"Error: Could not send zmq dummy header for streamer %d\n", index);
fifo->FreeAddress(buf); fifo->FreeAddress(buf);
StopRunning(); StopRunning();
#ifdef VERBOSE #ifdef VERBOSE
printf("%d: Streaming Completed\n", index); FILE_LOG(logINFO) << index << ": Streaming Completed";
#endif #endif
} }
@ -231,12 +231,12 @@ void DataStreamer::ProcessAnImage(char* buf) {
sls_detector_header* header = (sls_detector_header*) (buf); sls_detector_header* header = (sls_detector_header*) (buf);
uint64_t fnum = header->frameNumber; uint64_t fnum = header->frameNumber;
#ifdef VERBOSE #ifdef VERBOSE
cprintf(MAGENTA,"DataStreamer %d: fnum:%lu\n", index,fnum); bprintf(MAGENTA,"DataStreamer %d: fnum:%lu\n", index,fnum);
#endif #endif
if (!measurementStartedFlag) { if (!measurementStartedFlag) {
#ifdef VERBOSE #ifdef VERBOSE
if (!index) cprintf(MAGENTA,"DataStreamer %d: fnum:%lu\n", index, fnum); if (!index) bprintf(MAGENTA,"DataStreamer %d: fnum:%lu\n", index, fnum);
#endif #endif
RecordFirstIndices(fnum); RecordFirstIndices(fnum);
//restart timer //restart timer
@ -255,20 +255,20 @@ void DataStreamer::ProcessAnImage(char* buf) {
} }
if (!SendHeader(header)) if (!SendHeader(header))
cprintf(RED,"Error: Could not send zmq header for fnum %lld and streamer %d\n", bprintf(RED,"Error: Could not send zmq header for fnum %lld and streamer %d\n",
(long long int) fnum, index); (long long int) fnum, index);
//shortframe gotthard - data sending //shortframe gotthard - data sending
if (completeBuffer) { if (completeBuffer) {
memcpy(completeBuffer + ((generalData->imageSize)**shortFrameEnable), buf + sizeof(sls_detector_header), generalData->imageSize); memcpy(completeBuffer + ((generalData->imageSize)**shortFrameEnable), buf + sizeof(sls_detector_header), generalData->imageSize);
if (!zmqSocket->SendData(completeBuffer, generalData->imageSize_Streamer)) if (!zmqSocket->SendData(completeBuffer, generalData->imageSize_Streamer))
cprintf(RED,"Error: Could not send zmq data for fnum %lld and streamer %d\n", bprintf(RED,"Error: Could not send zmq data for fnum %lld and streamer %d\n",
(long long int) fnum, index); (long long int) fnum, index);
} }
//normal - data sending //normal - data sending
else { else {
if (!zmqSocket->SendData(buf + sizeof(sls_detector_header), generalData->imageSize)) if (!zmqSocket->SendData(buf + sizeof(sls_detector_header), generalData->imageSize))
cprintf(RED,"Error: Could not send zmq data for fnum %lld and streamer %d\n", bprintf(RED,"Error: Could not send zmq data for fnum %lld and streamer %d\n",
(long long int) fnum, index); (long long int) fnum, index);
} }
} }
@ -279,7 +279,7 @@ bool DataStreamer::CheckTimer() {
struct timespec end; struct timespec end;
clock_gettime(CLOCK_REALTIME, &end); clock_gettime(CLOCK_REALTIME, &end);
#ifdef VERBOSE #ifdef VERBOSE
cprintf(BLUE,"%d Timer elapsed time:%f seconds\n", index, ( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec ) / 1000000000.0); bprintf(BLUE,"%d Timer elapsed time:%f seconds\n", index, ( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec ) / 1000000000.0);
#endif #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 ) / 1000000000.0) < (*streamingTimerInMs/1000)) if((( end.tv_sec - timerBegin.tv_sec ) + ( end.tv_nsec - timerBegin.tv_nsec ) / 1000000000.0) < (*streamingTimerInMs/1000))

4
slsReceiverSoftware/src/Fifo.cpp
View File

@ -29,7 +29,7 @@ Fifo::Fifo(uint32_t fifoItemSize, uint32_t fifoDepth, bool &success):
Fifo::~Fifo() { Fifo::~Fifo() {
FILE_LOG (logDEBUG) << __AT__ << " called"; FILE_LOG (logDEBUG) << __AT__ << " called";
//cprintf(BLUE,"Fifo Object %d: Goodbye\n", index); //bprintf(BLUE,"Fifo Object %d: Goodbye\n", index);
DestroyFifos(); DestroyFifos();
NumberofFifoClassObjects--; NumberofFifoClassObjects--;
} }
@ -59,7 +59,7 @@ int Fifo::CreateFifos(uint32_t fifoItemSize, uint32_t fifoDepth) {
while (buffer < (memory + fifoItemSize * (fifoDepth-1))) { while (buffer < (memory + fifoItemSize * (fifoDepth-1))) {
//sprintf(buffer,"memory"); //sprintf(buffer,"memory");
#ifdef FIFODEBUG #ifdef FIFODEBUG
cprintf(MAGENTA,"Fifofree %d: value:%d, pop 0x%p\n", index, fifoFree->getSemValue(), (void*)(buffer)); bprintf(MAGENTA,"Fifofree %d: value:%d, pop 0x%p\n", index, fifoFree->getSemValue(), (void*)(buffer));
#endif #endif
FreeAddress(buffer); FreeAddress(buffer);
buffer += fifoItemSize; buffer += fifoItemSize;

54
slsReceiverSoftware/src/File.cpp
View File

@ -43,43 +43,25 @@ string File::GetCurrentFileName() {
} }
void File::PrintMembers() { void File::PrintMembers() {
printf("\nGeneral Writer Variables:" FILE_LOG(logINFO) << "\nGeneral Writer Variables:" << endl
"Index: %d\n" << "Index: " << index << endl
"Max Frames Per File: %u\n" << "Max Frames Per File: " << maxFramesPerFile << endl
"Packets per Frame: %u\n" << "Packets per Frame: " << *packetsPerFrame << endl
"Number of Detectors in x dir: %d\n" << "Number of Detectors in x dir: " << numDetX << endl
"Number of Detectors in y dir: %d\n" << "Number of Detectors in y dir: " << numDetY << endl
"File Name Prefix: %s\n" << "File Name Prefix: " << fileNamePrefix << endl
"File Path: %s\n" << "File Path: " << filePath << endl
"File Index: %lu\n" << "File Index: " << *fileIndex << endl
"Frame Index Enable: %d\n" << "Frame Index Enable: " << *frameIndexEnable << endl
"Over Write Enable: %d\n" << "Over Write Enable: " << *overWriteEnable << endl
"Detector Index: %d\n" << "Detector Index: " << *detIndex << endl
"Number of Units Per Detector: %d\n" << "Number of Units Per Detector: " << *numUnitsPerDetector << endl
"Number of Images in Acquisition: %lu\n" << "Number of Images in Acquisition: " << *numImages << endl
"Dynamic Range: %u\n" << "Dynamic Range: " << *dynamicRange << endl
"UDP Port number: %u\n" << "UDP Port number: " << *udpPortNumber << endl
"Master File Name: %s\n" << "Master File Name: " << masterFileName << endl
"Current File Name: %s\n", << "Current File Name: " << currentFileName;
index,
maxFramesPerFile,
*packetsPerFrame,
numDetX,
numDetY,
fileNamePrefix,
filePath,
*fileIndex,
(int)*frameIndexEnable,
(int)*overWriteEnable,
*detIndex,
*numUnitsPerDetector,
*numImages,
*dynamicRange,
*udpPortNumber,
masterFileName.c_str(),
currentFileName.c_str());
} }

20
slsReceiverSoftware/src/HDF5File.cpp
View File

@ -53,13 +53,13 @@ void HDF5File::PrintMembers() {
File::PrintMembers(); File::PrintMembers();
UpdateDataType(); UpdateDataType();
if (datatype == PredType::STD_U8LE) { if (datatype == PredType::STD_U8LE) {
printf("Data Type: 4 or 8\n"); FILE_LOG(logINFO) << "Data Type: 4 or 8";
} else if (datatype == PredType::STD_U16LE) { } else if (datatype == PredType::STD_U16LE) {
printf("Data Type: 16\n"); FILE_LOG(logINFO) << "Data Type: 16";
} else if (datatype == PredType::STD_U32LE) { } else if (datatype == PredType::STD_U32LE) {
printf("Data Type: 32\n"); FILE_LOG(logINFO) << "Data Type: 32";
} else { } else {
cprintf(BG_RED,"unknown data type\n"); FILE_LOG(logERROR) << BG_RED,"unknown data type";
} }
} }
@ -112,18 +112,18 @@ int HDF5File::CreateFile(uint64_t fnum) {
} }
pthread_mutex_unlock(&Mutex); pthread_mutex_unlock(&Mutex);
if (dataspace == NULL) if (dataspace == NULL)
cprintf(RED,"Got nothing!\n"); bprintf(RED,"Got nothing!\n");
//first file, print entrire path //first file, print entrire path
if (loss == -1) if (loss == -1)
printf("[%u]: HDF5 File created: %s\n", *udpPortNumber, currentFileName.c_str()); FILE_LOG(logINFO) << *udpPortNumber << ": HDF5 File created: " << currentFileName;
//other files //other files
else { else {
if (loss) if (loss)
cprintf(RED,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n", bprintf(RED,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n",
*udpPortNumber,loss, fifo->GetMaxLevelForFifoBound() , basename(currentFileName.c_str())); *udpPortNumber,loss, fifo->GetMaxLevelForFifoBound() , basename(currentFileName.c_str()));
else else
cprintf(GREEN,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n", bprintf(GREEN,"[%u]: Packet_Loss:%lu Fifo_Max_Level:%d \tNew_File:%s\n",
*udpPortNumber,loss, fifo->GetMaxLevelForFifoBound(), basename(currentFileName.c_str())); *udpPortNumber,loss, fifo->GetMaxLevelForFifoBound(), basename(currentFileName.c_str()));
} }
@ -172,7 +172,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); bprintf(RED,"%d Error: Write to file failed\n", index);
return FAIL; return FAIL;
} }
@ -187,7 +187,7 @@ int HDF5File::CreateMasterFile(bool en, uint32_t size,
if (master && (*detIndex==0)) { if (master && (*detIndex==0)) {
virtualfd = 0; virtualfd = 0;
masterFileName = HDF5FileStatic::CreateMasterFileName(filePath, fileNamePrefix, *fileIndex); masterFileName = HDF5FileStatic::CreateMasterFileName(filePath, fileNamePrefix, *fileIndex);
printf("Master File: %s\n", masterFileName.c_str()); FILE_LOG(logINFO) << "Master File: " << masterFileName;
pthread_mutex_lock(&Mutex); pthread_mutex_lock(&Mutex);
int ret = HDF5FileStatic::CreateMasterDataFile(masterfd, masterFileName, *overWriteEnable, int ret = HDF5FileStatic::CreateMasterDataFile(masterfd, masterFileName, *overWriteEnable,
*dynamicRange, en, size, nx, ny, *numImages, at, ap, HDF5_WRITER_VERSION); *dynamicRange, en, size, nx, ny, *numImages, at, ap, HDF5_WRITER_VERSION);

20
slsReceiverSoftware/src/Listener.cpp
View File

@ -177,7 +177,7 @@ void Listener::RecordFirstIndices(uint64_t fnum) {
acquisitionStartedFlag = true; acquisitionStartedFlag = true;
firstAcquisitionIndex = fnum; firstAcquisitionIndex = fnum;
} }
if (!index) cprintf(BLUE,"%d First Acquisition Index:%lu\n" if (!index) bprintf(BLUE,"%d First Acquisition Index:%lu\n"
"%d First Measurement Index:%lu\n", "%d First Measurement Index:%lu\n",
index, firstAcquisitionIndex, index, firstAcquisitionIndex,
index, firstMeasurementIndex); index, firstMeasurementIndex);
@ -219,7 +219,7 @@ int Listener::CreateUDPSockets() {
generalData->packetSize, (strlen(eth)?eth:NULL), generalData->headerPacketSize); generalData->packetSize, (strlen(eth)?eth:NULL), generalData->headerPacketSize);
int iret = udpSocket->getErrorStatus(); int iret = udpSocket->getErrorStatus();
if(!iret){ if(!iret){
cout << index << ": UDP port opened at port " << *udpPortNumber << endl; FILE_LOG(logINFO) << index << ": UDP port opened at port " << *udpPortNumber;
}else{ }else{
FILE_LOG(logERROR) << "Could not create UDP socket on port " << *udpPortNumber << " error: " << iret; FILE_LOG(logERROR) << "Could not create UDP socket on port " << *udpPortNumber << " error: " << iret;
return FAIL; return FAIL;
@ -247,7 +247,7 @@ void Listener::ThreadExecution() {
fifo->GetNewAddress(buffer); fifo->GetNewAddress(buffer);
#ifdef FIFODEBUG #ifdef FIFODEBUG
if (!index) cprintf(GREEN,"Listener %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer); if (!index) bprintf(GREEN,"Listener %d, pop 0x%p buffer:%s\n", index,(void*)(buffer),buffer);
#endif #endif
//udpsocket doesnt exist //udpsocket doesnt exist
@ -275,7 +275,7 @@ 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(BG_RED,"Error:(Weird Early self shut down), UDP Sockets not shut down, but received nothing\n"); //bprintf(BG_RED,"Error:(Weird Early self shut down), UDP Sockets not shut down, but received nothing\n");
StopListening(buffer); StopListening(buffer);
return; return;
} }
@ -297,8 +297,8 @@ void Listener::StopListening(char* buf) {
fifo->PushAddress(buf); fifo->PushAddress(buf);
StopRunning(); StopRunning();
#ifdef VERBOSE #ifdef VERBOSE
cprintf(GREEN,"%d: Listening Packets (%u) : %llu\n", index, *udpPortNumber, numPacketsCaught); bprintf(GREEN,"%d: Listening Packets (%u) : %llu\n", index, *udpPortNumber, numPacketsCaught);
printf("%d: Listening Completed\n", index); bprintf(GREEN,"%d: Listening Completed\n", index);
#endif #endif
} }
@ -327,7 +327,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); bprintf(RED,"%d carry flag\n",index);
//check if its the current image packet //check if its the current image packet
// -------------------------- new header ---------------------------------------------------------------------- // -------------------------- new header ----------------------------------------------------------------------
if (standardheader) { if (standardheader) {
@ -343,7 +343,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------
if (fnum != currentFrameIndex) { if (fnum != currentFrameIndex) {
if (fnum < currentFrameIndex) { if (fnum < currentFrameIndex) {
cprintf(BG_RED,"Error:(Weird), With carry flag: Frame number %lu less than current frame number %lu\n", fnum, currentFrameIndex); bprintf(BG_RED,"Error:(Weird), With carry flag: Frame number %lu less than current frame number %lu\n", fnum, currentFrameIndex);
return 0; return 0;
} }
new_header->packetNumber = numpackets; new_header->packetNumber = numpackets;
@ -426,7 +426,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
#ifdef VERBOSE #ifdef VERBOSE
//if (!index) //if (!index)
cprintf(GREEN,"Listening %d: currentfindex:%lu, fnum:%lu, pnum:%u numpackets:%u\n", bprintf(GREEN,"Listening %d: currentfindex:%lu, fnum:%lu, pnum:%u numpackets:%u\n",
index,currentFrameIndex, fnum, pnum, numpackets); index,currentFrameIndex, fnum, pnum, numpackets);
#endif #endif
if (!measurementStartedFlag) if (!measurementStartedFlag)
@ -436,7 +436,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//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\n"); //bprintf(RED,"setting carry over flag to true\n");
carryOverFlag = true; carryOverFlag = true;
memcpy(carryOverPacket,listeningPacket, generalData->packetSize); memcpy(carryOverPacket,listeningPacket, generalData->packetSize);

2
slsReceiverSoftware/src/ThreadObject.cpp
View File

@ -87,7 +87,7 @@ void ThreadObject::RunningThread() {
sem_wait(&semaphore); sem_wait(&semaphore);
if(killThread) { if(killThread) {
cprintf(BLUE,"%s Thread %d: Goodbye\n",GetType().c_str(),index); bprintf(BLUE,"%s Thread %d: Goodbye\n",GetType().c_str(),index);
pthread_exit(NULL); pthread_exit(NULL);
} }

42
slsReceiverSoftware/src/UDPStandardImplementation.cpp
View File

@ -133,7 +133,7 @@ void UDPStandardImplementation::setFileFormat(const fileFormat f){
int UDPStandardImplementation::setShortFrameEnable(const int i) { int UDPStandardImplementation::setShortFrameEnable(const int i) {
if (myDetectorType != GOTTHARD) { if (myDetectorType != GOTTHARD) {
cprintf(RED, "Error: Can not set short frame for this detector\n"); bprintf(RED, "Error: Can not set short frame for this detector\n");
return FAIL; return FAIL;
} }
@ -203,9 +203,9 @@ int UDPStandardImplementation::setDataStreamEnable(const bool enable) {
} }
if (DataStreamer::GetErrorMask() || error) { if (DataStreamer::GetErrorMask() || error) {
if (DataStreamer::GetErrorMask()) if (DataStreamer::GetErrorMask())
cprintf(BG_RED,"Error: Could not create data callback threads\n"); bprintf(BG_RED,"Error: Could not create data callback threads\n");
else else
cprintf(BG_RED,"Error: Could not create zmq sockets\n"); bprintf(BG_RED,"Error: Could not create zmq sockets\n");
for (vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it) for (vector<DataStreamer*>::const_iterator it = dataStreamer.begin(); it != dataStreamer.end(); ++it)
delete(*it); delete(*it);
dataStreamer.clear(); dataStreamer.clear();
@ -319,7 +319,7 @@ int UDPStandardImplementation::setFifoDepth(const uint32_t i) {
if (SetupFifoStructure() == FAIL) if (SetupFifoStructure() == FAIL)
return FAIL; return FAIL;
} }
FILE_LOG (logINFO) << "Fifo Depth: " << i << endl; FILE_LOG (logINFO) << "Fifo Depth: " << i;
return OK; return OK;
} }
@ -428,7 +428,7 @@ void UDPStandardImplementation::resetAcquisitionCount() {
int UDPStandardImplementation::startReceiver(char *c) { int UDPStandardImplementation::startReceiver(char *c) {
cout << endl << endl; bprintf(GRAY,"\n");
FILE_LOG(logINFO) << "Starting Receiver"; FILE_LOG(logINFO) << "Starting Receiver";
ResetParametersforNewMeasurement(); ResetParametersforNewMeasurement();
@ -445,7 +445,7 @@ int UDPStandardImplementation::startReceiver(char *c) {
startAcquisitionCallBack(filePath, fileName, fileIndex, startAcquisitionCallBack(filePath, fileName, fileIndex,
(generalData->imageSize) * numberofJobs + (generalData->fifoBufferHeaderSize), pStartAcquisition); (generalData->imageSize) * numberofJobs + (generalData->fifoBufferHeaderSize), pStartAcquisition);
if (rawDataReadyCallBack != NULL) { if (rawDataReadyCallBack != NULL) {
cout << "Data Write has been defined externally" << endl; FILE_LOG(logINFO) << "Data Write has been defined externally";
} }
} }
@ -457,9 +457,9 @@ int UDPStandardImplementation::startReceiver(char *c) {
return FAIL; return FAIL;
} }
} else } else
cout << "File Write Disabled" << endl; FILE_LOG(logINFO) << "File Write Disabled";
cout << "Ready ..." << endl; FILE_LOG(logINFO) << "Ready ...";
//status //status
pthread_mutex_lock(&statusMutex); pthread_mutex_lock(&statusMutex);
@ -517,19 +517,19 @@ void UDPStandardImplementation::stopReceiver(){
uint64_t missingpackets = numberOfFrames*generalData->packetsPerFrame-listener[i]->GetPacketsCaught(); uint64_t missingpackets = numberOfFrames*generalData->packetsPerFrame-listener[i]->GetPacketsCaught();
if (missingpackets) { if (missingpackets) {
cprintf(RED, "\n[Port %d]\n",udpPortNum[i]); bprintf(RED, "\n[Port %d]\n",udpPortNum[i]);
cprintf(RED, "Missing Packets\t\t: %lld\n",(long long int)missingpackets); bprintf(RED, "Missing Packets\t\t: %lld\n",(long long int)missingpackets);
cprintf(RED, "Complete Frames\t\t: %lld\n",(long long int)dataProcessor[i]->GetNumFramesCaught()); bprintf(RED, "Complete Frames\t\t: %lld\n",(long long int)dataProcessor[i]->GetNumFramesCaught());
cprintf(RED, "Last Frame Caught\t: %lld\n",(long long int)listener[i]->GetLastFrameIndexCaught()); bprintf(RED, "Last Frame Caught\t: %lld\n",(long long int)listener[i]->GetLastFrameIndexCaught());
}else{ }else{
cprintf(GREEN, "\n[Port %d]\n",udpPortNum[i]); bprintf(GREEN, "\n[Port %d]\n",udpPortNum[i]);
cprintf(GREEN, "Missing Packets\t\t: %lld\n",(long long int)missingpackets); bprintf(GREEN, "Missing Packets\t\t: %lld\n",(long long int)missingpackets);
cprintf(GREEN, "Complete Frames\t\t: %lld\n",(long long int)dataProcessor[i]->GetNumFramesCaught()); bprintf(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()); bprintf(GREEN, "Last Frame Caught\t: %lld\n",(long long int)listener[i]->GetLastFrameIndexCaught());
} }
} }
if(!activated) if(!activated)
cprintf(RED,"Note: Deactivated Receiver\n"); bprintf(RED,"Note: Deactivated Receiver\n");
//callback //callback
if (acquisitionFinishedCallBack) if (acquisitionFinishedCallBack)
acquisitionFinishedCallBack((tot/numThreads), pAcquisitionFinished); acquisitionFinishedCallBack((tot/numThreads), pAcquisitionFinished);
@ -563,7 +563,7 @@ void UDPStandardImplementation::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 #ifdef VERY_VERBOSE
cprintf(MAGENTA,"waiting for all packets prevP:%d totalP:%d\n", bprintf(MAGENTA,"waiting for all packets prevP:%d totalP:%d\n",
prev,totalP); prev,totalP);
#endif #endif
@ -576,7 +576,7 @@ void UDPStandardImplementation::startReadout(){
for (vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it) for (vector<Listener*>::const_iterator it = listener.begin(); it != listener.end(); ++it)
totalP += (*it)->GetPacketsCaught(); totalP += (*it)->GetPacketsCaught();
#ifdef VERY_VERBOSE #ifdef VERY_VERBOSE
cprintf(MAGENTA,"\tupdated: totalP:%d\n",totalP); bprintf(MAGENTA,"\tupdated: totalP:%d\n",totalP);
#endif #endif
} }
} }
@ -703,7 +703,7 @@ int UDPStandardImplementation::SetupFifoStructure() {
//must be > 0 and < max jobs //must be > 0 and < max jobs
numberofJobs = ((i < 1) ? 1 : ((i > MAX_JOBS_PER_THREAD) ? MAX_JOBS_PER_THREAD : i)); numberofJobs = ((i < 1) ? 1 : ((i > MAX_JOBS_PER_THREAD) ? MAX_JOBS_PER_THREAD : i));
} }
FILE_LOG (logINFO) << "Number of Jobs Per Thread:" << numberofJobs << endl; FILE_LOG (logINFO) << "Number of Jobs Per Thread:" << numberofJobs;
uint32_t oldfifodepth = fifoDepth; uint32_t oldfifodepth = fifoDepth;
//reduce fifo depth if numberofJobsPerBuffer > 1 (to save memory) //reduce fifo depth if numberofJobsPerBuffer > 1 (to save memory)
@ -731,7 +731,7 @@ int UDPStandardImplementation::SetupFifoStructure() {
(generalData->imageSize) * numberofJobs + (generalData->fifoBufferHeaderSize), (generalData->imageSize) * numberofJobs + (generalData->fifoBufferHeaderSize),
fifoDepth, success)); fifoDepth, success));
if (!success) { if (!success) {
cprintf(BG_RED,"Error: Could not allocate memory for fifo structure of index %d\n", i); bprintf(BG_RED,"Error: Could not allocate memory for fifo structure of index %d\n", i);
for (vector<Fifo*>::const_iterator it = fifo.begin(); it != fifo.end(); ++it) for (vector<Fifo*>::const_iterator it = fifo.begin(); it != fifo.end(); ++it)
delete(*it); delete(*it);
fifo.clear(); fifo.clear();

48
slsReceiverSoftware/src/dummyMain.cpp
View File

@ -1,48 +0,0 @@
/* A simple server in the internet domain using TCP
The port number is passed as an argument */
#include "sls_receiver_defs.h"
#include "dummyUDPInterface.h"
#include "slsReceiverTCPIPInterface.h"
#include <iostream>
#include <string.h>
using namespace std;
int main(int argc, char *argv[]) {
int success;
int tcpip_port_no;
bool bottom = false;
cout << "CCCCCC" << endl;
dummyUDPInterface *udp=new dummyUDPInterface();
// slsReceiverTCPIPInterface *tcpipInterface = new slsReceiverTCPIPInterface(success, udp, tcpip_port_no, bottom);
// if(tcpipInterface->start() == slsReceiverDefs::OK){
// cout << "DONE!" << endl;
// string str;
// cin>>str;
// //wait and look for an exit keyword
// while(str.find("exit") == string::npos)
// cin>>str;
// //stop tcp server thread, stop udp socket
// tcpipInterface->stop();
// }
// if (tcpipInterface)
// delete tcpipInterface;
udp->startReceiver();
if(udp)
delete udp;
return 0;
}

24
slsReceiverSoftware/src/main.cpp
View File

@ -25,23 +25,23 @@ void closeFile(int p){
/* /*
int startAcquisitionCallBack(char* filePath, char* fileName, int fileIndex, int bufferSize, void* context) { int startAcquisitionCallBack(char* filePath, char* fileName, int fileIndex, int bufferSize, void* context) {
cout << "#### startAcquisitionCallBack ####" << endl; FILE_LOG(logINFO) << "#### startAcquisitionCallBack ####";
cout << "* filePath: " << filePath << endl; FILE_LOG(logINFO) << "* filePath: " << filePath;
cout << "* fileName: " << fileName << endl; FILE_LOG(logINFO) << "* fileName: " << fileName;
cout << "* fileIndex: " << fileIndex << endl; FILE_LOG(logINFO) << "* fileIndex: " << fileIndex;
cout << "* bufferSize: " << bufferSize << endl; FILE_LOG(logINFO) << "* bufferSize: " << bufferSize;
return 1; return 1;
} }
void acquisitionFinishedCallBack(int totalFramesCaught, void* context) { void acquisitionFinishedCallBack(int totalFramesCaught, void* context) {
cout << "#### acquisitionFinishedCallBack ####" << endl; FILE_LOG(logINFO) << "#### acquisitionFinishedCallBack ####";
cout << "* totalFramesCaught: " << totalFramesCaught << endl; FILE_LOG(logINFO) << "* totalFramesCaught: " << totalFramesCaught;
} }
void rawDataReadyCallBack(int currFrameNum, char* dataPointer, int dataSize, FILE* file, char* guiDataPointer, void* context) { void rawDataReadyCallBack(int currFrameNum, char* dataPointer, int dataSize, FILE* file, char* guiDataPointer, void* context) {
cout << "#### rawDataReadyCallBack ####" << endl; FILE_LOG(logINFO) << "#### rawDataReadyCallBack ####";
cout << "* currFrameNum: " << currFrameNum << endl; FILE_LOG(logINFO) << "* currFrameNum: " << currFrameNum;
cout << "* dataSize: " << dataSize << endl; FILE_LOG(logINFO) << "* dataSize: " << dataSize;
} }
*/ */
@ -104,7 +104,7 @@ int main(int argc, char *argv[]) {
//start tcp server thread //start tcp server thread
if(receiver->start() == slsReceiverDefs::OK){ if(receiver->start() == slsReceiverDefs::OK){
FILE_LOG(logDEBUG1) << "DONE!" << endl; FILE_LOG(logDEBUG1) << "DONE!";
string str; string str;
cin>>str; cin>>str;
//wait and look for an exit keyword //wait and look for an exit keyword
@ -115,7 +115,7 @@ int main(int argc, char *argv[]) {
} }
deleteReceiver(receiver); deleteReceiver(receiver);
cout << "Goodbye!" << endl; FILE_LOG(logINFO) << "Goodbye!";
return 0; return 0;
} }

6
slsReceiverSoftware/src/slsReceiver.cpp
View File

@ -70,7 +70,9 @@ slsReceiver::slsReceiver(int argc, char *argv[], int &success){
case 'f': case 'f':
fname = optarg; fname = optarg;
//cout << long_options[option_index].name << " " << optarg << endl; #ifdef VERYVERBOSE
FILE_LOG(logDEBUG) << long_options[option_index].name << " " << optarg << endl;
#endif
break; break;
case 'b': case 'b':
@ -94,7 +96,7 @@ slsReceiver::slsReceiver(int argc, char *argv[], int &success){
help_message += """\t--type:\t Type of the receiver. Possible arguments are: standard, REST. Default: standard.\n\n"""; help_message += """\t--type:\t Type of the receiver. Possible arguments are: standard, REST. Default: standard.\n\n""";
cout << help_message << endl; FILE_LOG(logINFO) << help_message << endl;
break; break;
} }

269
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@ -70,7 +70,7 @@ slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int &success, UDPInterface*
strcpy(mess,"dummy message"); strcpy(mess,"dummy message");
function_table(); function_table();
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "Function table assigned." << endl; FILE_LOG(logINFO) << "Function table assigned.";
#endif #endif
} }
} }
@ -89,7 +89,7 @@ int slsReceiverTCPIPInterface::setPortNumber(int pn){
if (p_number<1024) { if (p_number<1024) {
sprintf(mess,"Too low port number %d\n", p_number); sprintf(mess,"Too low port number %d\n", p_number);
cout << mess << endl; bprintf(RED,"%s",mess);
} else { } else {
oldsocket=mySock; oldsocket=mySock;
@ -101,10 +101,9 @@ int slsReceiverTCPIPInterface::setPortNumber(int pn){
strcpy(mySock->lastClientIP,oldsocket->lastClientIP); strcpy(mySock->lastClientIP,oldsocket->lastClientIP);
delete oldsocket; delete oldsocket;
} else { } else {
cout << "Could not bind port " << p_number << endl; FILE_LOG(logERROR) << "Could not bind port " << p_number;
if (sd==-10) { if (sd==-10) {
FILE_LOG(logINFO) << "Port "<< p_number << " already set";
cout << "Port "<< p_number << " already set" << endl;
} else { } else {
delete mySock; delete mySock;
mySock=oldsocket; mySock=oldsocket;
@ -123,27 +122,26 @@ int slsReceiverTCPIPInterface::setPortNumber(int pn){
int slsReceiverTCPIPInterface::start(){ int slsReceiverTCPIPInterface::start(){
FILE_LOG(logDEBUG) << "Creating TCP Server Thread" << endl; FILE_LOG(logDEBUG) << "Creating TCP Server Thread";
killTCPServerThread = 0; killTCPServerThread = 0;
if(pthread_create(&TCPServer_thread, NULL,startTCPServerThread, (void*) this)){ if(pthread_create(&TCPServer_thread, NULL,startTCPServerThread, (void*) this)){
cout << "Could not create TCP Server thread" << endl; FILE_LOG(logERROR) << "Could not create TCP Server thread";
return FAIL; return FAIL;
} }
//#ifdef VERYVERBOSE //#ifdef VERYVERBOSE
FILE_LOG(logDEBUG) << "TCP Server thread created successfully." << endl; FILE_LOG(logDEBUG) << "TCP Server thread created successfully.";
//#endif //#endif
return OK; return OK;
} }
void slsReceiverTCPIPInterface::stop(){ void slsReceiverTCPIPInterface::stop(){
cout << "Shutting down UDP Socket" << endl; FILE_LOG(logINFO) << "Shutting down UDP Socket";
killTCPServerThread = 1; killTCPServerThread = 1;
if(mySock) mySock->ShutDownSocket(); if(mySock) mySock->ShutDownSocket();
cout<<"Socket closed"<<endl; FILE_LOG(logDEBUG) << "Socket closed";
pthread_join(TCPServer_thread, NULL); pthread_join(TCPServer_thread, NULL);
killTCPServerThread = 0; killTCPServerThread = 0;
cout<<"Threads joined"<<endl;
} }
@ -160,38 +158,38 @@ void slsReceiverTCPIPInterface::startTCPServer(){
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "Starting Receiver TCP Server" << endl; FILE_LOG(logDEBUG5) << "Starting Receiver TCP Server";
#endif #endif
int v=OK; int v=OK;
while(1) { while(1) {
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout<< endl; FILE_LOG(logDEBUG5);
#endif #endif
#ifdef VERY_VERBOSE #ifdef VERY_VERBOSE
cout << "Waiting for client call" << endl; FILE_LOG(logDEBUG5) << "Waiting for client call";
#endif #endif
if(mySock->Connect()>=0){ if(mySock->Connect()>=0){
#ifdef VERY_VERBOSE #ifdef VERY_VERBOSE
cout << "Conenction accepted" << endl; FILE_LOG(logDEBUG5) << "Conenction accepted";
#endif #endif
v = decode_function(); v = decode_function();
#ifdef VERY_VERBOSE #ifdef VERY_VERBOSE
cout << "function executed" << endl; FILE_LOG(logDEBUG5) << "function executed";
#endif #endif
mySock->Disconnect(); mySock->Disconnect();
#ifdef VERY_VERBOSE #ifdef VERY_VERBOSE
cout << "connection closed" << endl; FILE_LOG(logDEBUG5) << "connection closed";
#endif #endif
} }
//if tcp command was to exit server //if tcp command was to exit server
if(v==GOODBYE){ if(v==GOODBYE){
cout << "Shutting down UDP Socket" << endl; FILE_LOG(logINFO) << "Shutting down UDP Socket";
if(receiverBase){ if(receiverBase){
receiverBase->shutDownUDPSockets(); receiverBase->shutDownUDPSockets();
cout << "Closing Files... " << endl; FILE_LOG(logINFO) << "Closing Files... ";
receiverBase->closeFiles(); receiverBase->closeFiles();
} }
@ -269,7 +267,7 @@ int slsReceiverTCPIPInterface::function_table(){
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
for (int i=0;i<numberOfFunctions;i++) for (int i=0;i<numberOfFunctions;i++)
cout << "function " << i << "located at " << flist[i] << endl; FILE_LOG(logDEBUG1) << "function " << i << "located at " << flist[i];
#endif #endif
return OK; return OK;
@ -283,22 +281,22 @@ int slsReceiverTCPIPInterface::decode_function(){
ret = FAIL; ret = FAIL;
int n,fnum; int n,fnum;
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "receive data" << endl; FILE_LOG(logDEBUG1) << "receive data";
#endif #endif
n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum)); n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum));
if (n <= 0) { if (n <= 0) {
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "ERROR reading from socket " << n << ", " << fnum << endl; FILE_LOG(logDEBUG1) << "ERROR reading from socket " << n << ", " << fnum;
#endif #endif
return FAIL; return FAIL;
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
else else
cout << "size of data received " << n <<endl; FILE_LOG(logDEBUG1) << "size of data received " << n;
#endif #endif
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "calling function fnum = "<< fnum << dec << ":"<< flist[fnum] << endl; FILE_LOG(logDEBUG1) << "calling function fnum = "<< fnum << dec << ":"<< flist[fnum];
#endif #endif
if (fnum<0 || fnum>numberOfFunctions-1) if (fnum<0 || fnum>numberOfFunctions-1)
@ -306,7 +304,7 @@ int slsReceiverTCPIPInterface::decode_function(){
//calling function //calling function
(this->*flist[fnum])(); (this->*flist[fnum])();
if (ret==FAIL) if (ret==FAIL)
cprintf(RED, "Error executing the function = %d\n",fnum); bprintf(RED, "Error executing the function = %d\n",fnum);
return ret; return ret;
} }
@ -320,7 +318,7 @@ int slsReceiverTCPIPInterface::M_nofunc(){
ret=FAIL; ret=FAIL;
sprintf(mess,"Unrecognized Function\n"); sprintf(mess,"Unrecognized Function\n");
cout << mess << endl; FILE_LOG(logERROR) << mess;
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
@ -358,7 +356,7 @@ int slsReceiverTCPIPInterface::set_detector_type(){
} }
else if((receiverBase)&&(receiverBase->getStatus()!= IDLE)){ else if((receiverBase)&&(receiverBase->getStatus()!= IDLE)){
strcpy(mess,"Can not set detector type while receiver not idle\n"); strcpy(mess,"Can not set detector type while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -399,7 +397,7 @@ int slsReceiverTCPIPInterface::set_detector_type(){
if(ret!=FAIL) if(ret!=FAIL)
FILE_LOG(logDEBUG) << "detector type " << dr; FILE_LOG(logDEBUG) << "detector type " << dr;
else else
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
//#endif //#endif
#endif #endif
@ -451,7 +449,7 @@ int slsReceiverTCPIPInterface::set_file_name() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set file name while receiver not idle\n"); strcpy(mess,"Can not set file name while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -463,9 +461,9 @@ int slsReceiverTCPIPInterface::set_file_name() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "file name:" << retval << endl; FILE_LOG(logDEBUG1) << "file name:" << retval;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -478,7 +476,7 @@ int slsReceiverTCPIPInterface::set_file_name() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
if(retval == NULL) if(retval == NULL)
@ -524,7 +522,7 @@ int slsReceiverTCPIPInterface::set_file_dir() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set file path while receiver not idle\n"); strcpy(mess,"Can not set file path while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -539,9 +537,9 @@ int slsReceiverTCPIPInterface::set_file_dir() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "file path:" << retval << endl; FILE_LOG(logDEBUG1) << "file path:" << retval;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -553,7 +551,7 @@ int slsReceiverTCPIPInterface::set_file_dir() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
if(retval == NULL) if(retval == NULL)
@ -598,7 +596,7 @@ int slsReceiverTCPIPInterface::set_file_index() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set file index while receiver not idle\n"); strcpy(mess,"Can not set file index while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -611,9 +609,9 @@ int slsReceiverTCPIPInterface::set_file_index() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "file index:" << retval << endl; FILE_LOG(logDEBUG1) << "file index:" << retval;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -625,7 +623,7 @@ int slsReceiverTCPIPInterface::set_file_index() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -667,7 +665,7 @@ int slsReceiverTCPIPInterface::set_frame_index() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set frame index while receiver not idle\n"); strcpy(mess,"Can not set frame index while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -689,9 +687,9 @@ int slsReceiverTCPIPInterface::set_frame_index() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "frame index:" << retval << endl; FILE_LOG(logDEBUG1) << "frame index:" << retval;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -703,7 +701,7 @@ int slsReceiverTCPIPInterface::set_frame_index() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -749,7 +747,7 @@ int slsReceiverTCPIPInterface::setup_udp(){
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set up udp while receiver not idle\n"); strcpy(mess,"Can not set up udp while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -844,7 +842,7 @@ int slsReceiverTCPIPInterface::start_receiver(){
ret=receiverBase->startReceiver(mess); ret=receiverBase->startReceiver(mess);
else{ else{
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());
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
} }
} }
@ -858,7 +856,7 @@ int slsReceiverTCPIPInterface::start_receiver(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "Error:%s\n", mess); bprintf(RED, "Error:%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
//return ok/fail //return ok/fail
@ -892,7 +890,7 @@ int slsReceiverTCPIPInterface::stop_receiver(){
ret = OK; ret = OK;
else{ else{
sprintf(mess,"Could not stop receiver. It is in %s state\n",runStatusType(s).c_str()); sprintf(mess,"Could not stop receiver. It is in %s state\n",runStatusType(s).c_str());
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
} }
@ -906,7 +904,7 @@ int slsReceiverTCPIPInterface::stop_receiver(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
//return ok/fail //return ok/fail
@ -937,7 +935,7 @@ int slsReceiverTCPIPInterface::get_status(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
retval = (runStatus(s)); retval = (runStatus(s));
@ -968,7 +966,7 @@ int slsReceiverTCPIPInterface::get_frames_caught(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1000,7 +998,7 @@ int slsReceiverTCPIPInterface::get_frame_index(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1045,7 +1043,7 @@ int slsReceiverTCPIPInterface::reset_frames_caught(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
//return ok/fail //return ok/fail
@ -1091,7 +1089,7 @@ int slsReceiverTCPIPInterface::set_short_frame() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Cannot set short frame while status is running\n"); strcpy(mess,"Cannot set short frame while status is running\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
} }
else{ else{
@ -1109,7 +1107,7 @@ int slsReceiverTCPIPInterface::set_short_frame() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1203,7 +1201,7 @@ int slsReceiverTCPIPInterface::set_read_frequency(){
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set receiver frequency mode while receiver not idle\n"); strcpy(mess,"Can not set receiver frequency mode while receiver not idle\n");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1211,13 +1209,13 @@ int slsReceiverTCPIPInterface::set_read_frequency(){
ret = receiverBase->setFrameToGuiFrequency(index); ret = receiverBase->setFrameToGuiFrequency(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");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
} }
} }
retval=receiverBase->getFrameToGuiFrequency(); retval=receiverBase->getFrameToGuiFrequency();
if(index>=0 && retval!=index){ if(index>=0 && retval!=index){
strcpy(mess,"Could not set frame to gui frequency"); strcpy(mess,"Could not set frame to gui frequency");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
ret = FAIL; ret = FAIL;
} }
} }
@ -1233,7 +1231,7 @@ int slsReceiverTCPIPInterface::set_read_frequency(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1273,7 +1271,7 @@ int slsReceiverTCPIPInterface::set_read_receiver_timer(){
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set receiver frequency mode while receiver not idle\n"); strcpy(mess,"Can not set receiver frequency mode while receiver not idle\n");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1283,7 +1281,7 @@ int slsReceiverTCPIPInterface::set_read_receiver_timer(){
retval=receiverBase->getFrameToGuiTimer(); retval=receiverBase->getFrameToGuiTimer();
if(index>=0 && retval!=index){ if(index>=0 && retval!=index){
strcpy(mess,"Could not set datastream timer"); strcpy(mess,"Could not set datastream timer");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
ret = FAIL; ret = FAIL;
} }
} }
@ -1299,7 +1297,7 @@ int slsReceiverTCPIPInterface::set_read_receiver_timer(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1337,7 +1335,7 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){
} }
else if((index >= 0) && (receiverBase->getStatus()!= IDLE)){ else if((index >= 0) && (receiverBase->getStatus()!= IDLE)){
strcpy(mess,"Can not set data stream enable while receiver not idle\n"); strcpy(mess,"Can not set data stream enable while receiver not idle\n");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1346,7 +1344,7 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){
retval=receiverBase->getDataStreamEnable(); retval=receiverBase->getDataStreamEnable();
if(index>=0 && retval!=index){ if(index>=0 && retval!=index){
strcpy(mess,"Could not set data stream enable"); strcpy(mess,"Could not set data stream enable");
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
ret = FAIL; ret = FAIL;
} }
} }
@ -1362,7 +1360,7 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1401,7 +1399,7 @@ int slsReceiverTCPIPInterface::enable_file_write(){
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set file write mode while receiver not idle\n"); strcpy(mess,"Can not set file write mode while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1422,7 +1420,7 @@ int slsReceiverTCPIPInterface::enable_file_write(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1466,7 +1464,7 @@ int64_t slsReceiverTCPIPInterface::getReceiverVersion(){
int slsReceiverTCPIPInterface::start_readout(){cprintf(BLUE,"In start readout!\n"); int slsReceiverTCPIPInterface::start_readout(){bprintf(BLUE,"In start readout!\n");
ret=OK; ret=OK;
enum runStatus retval; enum runStatus retval;
@ -1498,7 +1496,7 @@ int slsReceiverTCPIPInterface::start_readout(){cprintf(BLUE,"In start readout!\n
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1538,7 +1536,7 @@ int slsReceiverTCPIPInterface::set_timer() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set timer while receiver not idle\n"); strcpy(mess,"Can not set timer while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1568,13 +1566,13 @@ int slsReceiverTCPIPInterface::set_timer() {
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL){ if(ret!=FAIL){
if(index[0] == ACQUISITION_TIME) if(index[0] == ACQUISITION_TIME)
cout << "acquisition time:" << retval << endl; FILE_LOG(logDEBUG1) << "acquisition time:" << retval;
else if(index[0] == FRAME_PERIOD) else if(index[0] == FRAME_PERIOD)
cout << "acquisition period:" << retval << endl; FILE_LOG(logDEBUG1) << "acquisition period:" << retval
else else
cout << "frame number:" << retval << endl; FILE_LOG(logDEBUG1) << "frame number:" << retval;
}else }else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -1586,7 +1584,7 @@ int slsReceiverTCPIPInterface::set_timer() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1627,7 +1625,7 @@ int slsReceiverTCPIPInterface::enable_compression() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Cannot enable/disable compression while status is running\n"); strcpy(mess,"Cannot enable/disable compression while status is running\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
} }
else{ else{
@ -1658,7 +1656,7 @@ int slsReceiverTCPIPInterface::enable_compression() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1697,7 +1695,7 @@ int slsReceiverTCPIPInterface::set_detector_hostname() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set detector hostname while receiver not idle\n"); strcpy(mess,"Can not set detector hostname while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1710,9 +1708,9 @@ int slsReceiverTCPIPInterface::set_detector_hostname() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "hostname:" << retval << endl; FILE_LOG(logDEBUG1) << "hostname:" << retval;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -1724,7 +1722,7 @@ int slsReceiverTCPIPInterface::set_detector_hostname() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
if(retval == NULL) if(retval == NULL)
@ -1772,7 +1770,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range() {
case 32:break; case 32:break;
default: default:
sprintf(mess,"This dynamic range does not exist: %d\n",dr); sprintf(mess,"This dynamic range does not exist: %d\n",dr);
cprintf(RED,"%s", mess); bprintf(RED,"%s", mess);
ret=FAIL; ret=FAIL;
break; break;
} }
@ -1784,7 +1782,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set dynamic range while receiver not idle\n"); strcpy(mess,"Can not set dynamic range while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1801,9 +1799,9 @@ int slsReceiverTCPIPInterface::set_dynamic_range() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "dynamic range" << dr << endl; FILE_LOG(logDEBUG1) << "dynamic range" << dr;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -1815,7 +1813,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1856,7 +1854,7 @@ int slsReceiverTCPIPInterface::enable_overwrite() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set overwrite mode while receiver not idle\n"); strcpy(mess,"Can not set overwrite mode while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1869,9 +1867,9 @@ int slsReceiverTCPIPInterface::enable_overwrite() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "overwrite:" << retval << endl; FILE_LOG(logDEBUG1) << "overwrite:" << retval;
else else
cout << mess << endl; FILE_LOG(logERROR) << mess;
#endif #endif
#endif #endif
@ -1883,7 +1881,7 @@ int slsReceiverTCPIPInterface::enable_overwrite() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1924,7 +1922,7 @@ int slsReceiverTCPIPInterface::enable_tengiga() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set up 1Giga/10Giga mode while receiver not idle\n"); strcpy(mess,"Can not set up 1Giga/10Giga mode while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -1939,9 +1937,9 @@ int slsReceiverTCPIPInterface::enable_tengiga() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "10Gbe:" << val << endl; FILE_LOG(logDEBUG1) << "10Gbe:" << val;
else else
cout << mess << endl; FILE_LOG(logDEBUG1) << mess;
#endif #endif
#endif #endif
@ -1953,7 +1951,7 @@ int slsReceiverTCPIPInterface::enable_tengiga() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -1994,7 +1992,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Cannot set/get fifo depth while status is running\n"); strcpy(mess,"Cannot set/get fifo depth while status is running\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
} }
else{ else{
@ -2025,7 +2023,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -2048,7 +2046,7 @@ int slsReceiverTCPIPInterface::set_activate() {
// receive arguments // receive arguments
if(mySock->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){ if(mySock->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){
strcpy(mess,"Error reading from socket\n"); strcpy(mess,"Error reading from socket\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
@ -2064,11 +2062,11 @@ int slsReceiverTCPIPInterface::set_activate() {
if(ret!=FAIL){ if(ret!=FAIL){
if (receiverBase == NULL){ if (receiverBase == NULL){
strcpy(mess,SET_RECEIVER_ERR_MESSAGE); strcpy(mess,SET_RECEIVER_ERR_MESSAGE);
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
}else if(receiverBase->getStatus()==RUNNING){ }else if(receiverBase->getStatus()==RUNNING){
strcpy(mess,"Cannot activate/deactivate while status is running\n"); strcpy(mess,"Cannot activate/deactivate while status is running\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
}else{ }else{
if(enable != -1) if(enable != -1)
@ -2077,7 +2075,7 @@ int slsReceiverTCPIPInterface::set_activate() {
if(enable >= 0 && retval != enable){ if(enable >= 0 && retval != enable){
sprintf(mess,"Tried to set activate to %d, but returned %d\n",enable,retval); sprintf(mess,"Tried to set activate to %d, but returned %d\n",enable,retval);
ret = FAIL; ret = FAIL;
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
} }
} }
} }
@ -2085,9 +2083,9 @@ int slsReceiverTCPIPInterface::set_activate() {
#endif #endif
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "Activate: " << retval << endl; FILE_LOG(logDEBUG1) << "Activate: " << retval;
else else
cout << mess << endl; FILE_LOG(logDEBUG1) << mess;
#endif #endif
@ -2099,7 +2097,7 @@ int slsReceiverTCPIPInterface::set_activate() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -2138,7 +2136,7 @@ int slsReceiverTCPIPInterface::set_flipped_data(){
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set flipped data while receiver not idle\n"); strcpy(mess,"Can not set flipped data while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -2149,9 +2147,9 @@ int slsReceiverTCPIPInterface::set_flipped_data(){
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL){ if(ret!=FAIL){
cout << "Flipped Data:" << retval << endl; FILE_LOG(logDEBUG1) << "Flipped Data:" << retval;
}else }else
cout << mess << endl; FILE_LOG(logDEBUG1) << mess;
#endif #endif
#endif #endif
@ -2163,7 +2161,7 @@ int slsReceiverTCPIPInterface::set_flipped_data(){
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -2185,7 +2183,7 @@ int slsReceiverTCPIPInterface::set_file_format() {
// receive arguments // receive arguments
if(mySock->ReceiveDataOnly(&f,sizeof(f)) < 0 ){ if(mySock->ReceiveDataOnly(&f,sizeof(f)) < 0 ){
strcpy(mess,"Error reading from socket\n"); strcpy(mess,"Error reading from socket\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
@ -2201,11 +2199,11 @@ int slsReceiverTCPIPInterface::set_file_format() {
if(ret!=FAIL){ if(ret!=FAIL){
if (receiverBase == NULL){ if (receiverBase == NULL){
strcpy(mess,SET_RECEIVER_ERR_MESSAGE); strcpy(mess,SET_RECEIVER_ERR_MESSAGE);
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
}else if(receiverBase->getStatus()==RUNNING && (f>=0)){ }else if(receiverBase->getStatus()==RUNNING && (f>=0)){
strcpy(mess,"Cannot set file format while status is running\n"); strcpy(mess,"Cannot set file format while status is running\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret=FAIL; ret=FAIL;
}else{ }else{
if(f != -1) if(f != -1)
@ -2214,7 +2212,7 @@ int slsReceiverTCPIPInterface::set_file_format() {
if(f >= 0 && retval != f){ if(f >= 0 && retval != f){
sprintf(mess,"Tried to set file format to %d, but returned %d\n",f,retval); sprintf(mess,"Tried to set file format to %d, but returned %d\n",f,retval);
ret = FAIL; ret = FAIL;
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
} }
} }
} }
@ -2222,9 +2220,9 @@ int slsReceiverTCPIPInterface::set_file_format() {
#endif #endif
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "File Format: " << retval << endl; FILE_LOG(logDEBUG1) << "File Format: " << retval;
else else
cout << mess << endl; FILE_LOG(logDEBUG1) << mess;
#endif #endif
@ -2236,7 +2234,7 @@ int slsReceiverTCPIPInterface::set_file_format() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -2274,7 +2272,7 @@ int slsReceiverTCPIPInterface::set_detector_posid() {
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set position file id while receiver not idle\n"); strcpy(mess,"Can not set position file id while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -2287,9 +2285,9 @@ int slsReceiverTCPIPInterface::set_detector_posid() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "Position Id:" << retval << endl; FILE_LOG(logDEBUG1) << "Position Id:" << retval;
else else
cout << mess << endl; FILE_LOG(logDEBUG1) << mess;
#endif #endif
#endif #endif
@ -2301,7 +2299,7 @@ int slsReceiverTCPIPInterface::set_detector_posid() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -2340,11 +2338,11 @@ int slsReceiverTCPIPInterface::set_multi_detector_size() {
else if (receiverBase == NULL){ else if (receiverBase == NULL){
strcpy(mess,SET_RECEIVER_ERR_MESSAGE); strcpy(mess,SET_RECEIVER_ERR_MESSAGE);
ret=FAIL; ret=FAIL;
cprintf(RED, "%s", mess); bprintf(RED, "%s", mess);
} }
else if(receiverBase->getStatus()!= IDLE){ else if(receiverBase->getStatus()!= IDLE){
strcpy(mess,"Can not set position file id while receiver not idle\n"); strcpy(mess,"Can not set position file id while receiver not idle\n");
cprintf(RED,"%s",mess); bprintf(RED,"%s",mess);
ret = FAIL; ret = FAIL;
} }
else{ else{
@ -2354,9 +2352,9 @@ int slsReceiverTCPIPInterface::set_multi_detector_size() {
} }
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
if(ret!=FAIL) if(ret!=FAIL)
cout << "Multi Detector Size:" << retval << endl; FILE_LOG(logDEBUG1) << "Multi Detector Size:" << retval;
else else
cout << mess << endl; FILE_LOG(logDEBUG1) << mess;
#endif #endif
#endif #endif
@ -2368,7 +2366,7 @@ int slsReceiverTCPIPInterface::set_multi_detector_size() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED, "%s\n", mess); bprintf(RED, "%s\n", mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
mySock->SendDataOnly(&retval,sizeof(retval)); mySock->SendDataOnly(&retval,sizeof(retval));
@ -2410,7 +2408,7 @@ int slsReceiverTCPIPInterface::lock_receiver() {
// receive arguments // receive arguments
if(mySock->ReceiveDataOnly(&lock,sizeof(lock)) < 0 ){ if(mySock->ReceiveDataOnly(&lock,sizeof(lock)) < 0 ){
sprintf(mess,"Error reading from socket\n"); sprintf(mess,"Error reading from socket\n");
cout << "Error reading from socket (lock)" << endl; FILE_LOG(logERROR) << "Error reading from socket (lock)";
ret=FAIL; ret=FAIL;
} }
// execute action if the arguments correctly arrived // execute action if the arguments correctly arrived
@ -2432,7 +2430,7 @@ int slsReceiverTCPIPInterface::lock_receiver() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
} }
else else
@ -2459,13 +2457,12 @@ int slsReceiverTCPIPInterface::set_port() {
// receive arguments // receive arguments
if(mySock->ReceiveDataOnly(&p_type,sizeof(p_type)) < 0 ){ if(mySock->ReceiveDataOnly(&p_type,sizeof(p_type)) < 0 ){
strcpy(mess,"Error reading from socket\n"); strcpy(mess,"Error reading from socket\n");
cout << mess << endl; FILE_LOG(logERROR) << mess;
ret=FAIL; ret=FAIL;
} }
if(mySock->ReceiveDataOnly(&p_number,sizeof(p_number)) < 0 ){ if(mySock->ReceiveDataOnly(&p_number,sizeof(p_number)) < 0 ){
strcpy(mess,"Error reading from socket\n"); strcpy(mess,"Error reading from socket\n");
cout << mess << endl; FILE_LOG(logERROR) << mess;
ret=FAIL; ret=FAIL;
} }
@ -2478,10 +2475,10 @@ int slsReceiverTCPIPInterface::set_port() {
else { else {
if (p_number<1024) { if (p_number<1024) {
sprintf(mess,"Too low port number %d\n", p_number); sprintf(mess,"Too low port number %d\n", p_number);
cout << mess << endl; FILE_LOG(logERROR) << mess;
ret=FAIL; ret=FAIL;
} }
cout << "set port " << p_type << " to " << p_number <<endl; FILE_LOG(logINFO) << "set port " << p_type << " to " << p_number <<endl;
strcpy(oldLastClientIP, mySock->lastClientIP); strcpy(oldLastClientIP, mySock->lastClientIP);
mySocket = new MySocketTCP(p_number); mySocket = new MySocketTCP(p_number);
} }
@ -2495,10 +2492,10 @@ int slsReceiverTCPIPInterface::set_port() {
} else { } else {
ret=FAIL; ret=FAIL;
sprintf(mess,"Could not bind port %d\n", p_number); sprintf(mess,"Could not bind port %d\n", p_number);
cout << mess << endl; FILE_LOG(logERROR) << mess;
if (sd==-10) { if (sd==-10) {
sprintf(mess,"Port %d already set\n", p_number); sprintf(mess,"Port %d already set\n", p_number);
cout << mess << endl; FILE_LOG(logERROR) << mess;
} }
} }
} }
@ -2507,7 +2504,7 @@ int slsReceiverTCPIPInterface::set_port() {
// send answer // send answer
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
}else { }else {
mySock->SendDataOnly(&p_number,sizeof(p_number)); mySock->SendDataOnly(&p_number,sizeof(p_number));
@ -2606,7 +2603,7 @@ int slsReceiverTCPIPInterface::update_client() {
} }
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){ if(ret==FAIL){
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
return ret; return ret;
} }
@ -2625,7 +2622,7 @@ int slsReceiverTCPIPInterface::exit_server() {
mySock->SendDataOnly(&ret,sizeof(ret)); mySock->SendDataOnly(&ret,sizeof(ret));
strcpy(mess,"closing server"); strcpy(mess,"closing server");
mySock->SendDataOnly(mess,sizeof(mess)); mySock->SendDataOnly(mess,sizeof(mess));
cprintf(RED,"%s\n",mess); bprintf(RED,"%s\n",mess);
return ret; return ret;
} }
@ -2648,7 +2645,7 @@ int slsReceiverTCPIPInterface::exec_command() {
// execute action if the arguments correctly arrived // execute action if the arguments correctly arrived
if (ret==OK) { if (ret==OK) {
#ifdef VERYVERBOSE #ifdef VERYVERBOSE
cout << "executing command " << cmd << endl; FILE_LOG(logDEBUG5) << "executing command " << cmd;
#endif #endif
if (lockStatus==0 || mySock->differentClients==0) if (lockStatus==0 || mySock->differentClients==0)
sysret=system(cmd); sysret=system(cmd);

4
slsReceiverSoftware/src/utilities.cpp
View File

@ -54,9 +54,9 @@ int read_config_file(string fname, int *tcpip_port_no, map<string, string> * con
if(sstr.good()) { if(sstr.good()) {
sstr >> sargname; sstr >> sargname;
if(sscanf(sargname.c_str(),"%d",tcpip_port_no)) if(sscanf(sargname.c_str(),"%d",tcpip_port_no))
cout<<"dataport:"<<tcpip_port_no<<endl; bprintf(GRAY, "dataport: %d\n" , *tcpip_port_no);
else{ else{
cout << "could not decode port in config file. Exiting." << endl; bprintf(RED, "could not decode port in config file. Exiting.\n");
success = slsReceiverDefs::FAIL; success = slsReceiverDefs::FAIL;
} }
} }

31
slsReceiverSoftware/test/rec.cxx
View File

@ -1,31 +0,0 @@
//version 1.0, base development ij 19/01/09
#include <iostream>
#include "MySocketTCP.h"
using namespace std;
int main(){
char data[50000];
int length=50000;
unsigned short int portnum = 1952;
MySocketTCP* sock = new MySocketTCP(portnum);
cout<<"\tReceived :"<<sock->ReceiveDataAndKeepConnection(data,23000)<<endl;
cout<<"\tReceived :"<<sock->ReceiveData(data,32200)<<endl;
cout<<"\tReceived :"<<sock->ReceiveData(data,33300)<<endl;
cout<<"\tReceived :"<<sock->ReceiveData(data,30000)<<endl;
cout<<"\tReceived :"<<sock->ReceiveData(data,3222)<<endl;
delete sock;
return 0;
}

40
slsReceiverSoftware/test/send.cxx
View File

@ -1,40 +0,0 @@
//version 1.0, base development ij 19/01/09
#include <iostream>
#include "MySocketTCP.h"
using namespace std;
int main(int argc, char *argv[]){
if(argc!=2){
cout<<"Usage: send ip_addess/hostName"<<endl;
return 1;
}
cout<<"rec function must be first called."<<endl;
char ip_address[200];
sprintf(ip_address,"%s",argv[1]);
unsigned short int portnum = 1952;
char data[50000];
int length=50000;
MySocketTCP* sock = new MySocketTCP(ip_address,portnum);
cout<<"\tSending :"<<sock->SendDataAndKeepConnection(data,2000)<<endl;
cout<<"\tSending :"<<sock->SendData(data,2200)<<endl;
cout<<"\tSending :"<<sock->SendData(data,1200)<<endl;
cout<<"\tSending :"<<sock->SendData(data,25000)<<endl;
cout<<"\tSending :"<<sock->SendData(data,222)<<endl;
delete sock;
return 0;
}