detectors/slsDetectorPackage
24
1
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2026-02-06 22:58:41 +01:00
Code Issues Actions Packages Releases Activity

clang format on receiver TCP and Implementation

Browse Source
This commit is contained in:
Erik Frojdh
2019-06-06 08:07:40 +02:00
parent 3d6404952a
commit 72e0d7e168
4 changed files with 3162 additions and 3107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
slsReceiverSoftware/include/slsReceiverImplementation.h
View File

@@ -1,15 +1,19 @@
#pragma once #pragma once
/********************************************/ /** /********************************************/ /**
* @file slsReceiverImplementation.h * @file
* @short does all the functions for a receiver, set/get parameters, start/stop etc. *slsReceiverImplementation.h
* @short does all the functions
*for a receiver, set/get
*parameters, start/stop etc.
***********************************************/ ***********************************************/
/** /**
* @short does all the functions for a receiver, set/get parameters, start/stop etc. * @short does all the functions for a receiver, set/get parameters, start/stop
* etc.
*/ */
// #include "sls_detector_defs.h" // #include "sls_detector_defs.h"
#include "receiver_defs.h"
#include "logger.h"
#include "container_utils.h" #include "container_utils.h"
#include "logger.h"
#include "receiver_defs.h"
class GeneralData; class GeneralData;
class Listener; class Listener;
class DataProcessor; class DataProcessor;
@@ -18,13 +22,11 @@ class Fifo;
class slsDetectorDefs; class slsDetectorDefs;
#include <exception> #include <exception>
#include <vector>
#include <memory> #include <memory>
#include <vector>
class slsReceiverImplementation : private virtual slsDetectorDefs { class slsReceiverImplementation : private virtual slsDetectorDefs {
public: public:
//*** cosntructor & destructor *** //*** cosntructor & destructor ***
/** /**
* Constructor * Constructor
@@ -36,7 +38,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
virtual ~slsReceiverImplementation(); virtual ~slsReceiverImplementation();
/************************************************************************* /*************************************************************************
* Getters *************************************************************** * Getters ***************************************************************
* They access local cache of configuration or detector parameters ******* * They access local cache of configuration or detector parameters *******
@@ -79,7 +80,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
readOutFlags getReadOutFlags() const; readOutFlags getReadOutFlags() const;
//***file parameters*** //***file parameters***
/** /**
* Get File Format * Get File Format
@@ -87,7 +87,8 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
fileFormat getFileFormat() const; fileFormat getFileFormat() const;
/** /**
* Get File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw)) * Get File Name Prefix (without frame index, file index and extension
* (_d0_f000000000000_8.raw))
* @return file name prefix * @return file name prefix
*/ */
std::string getFileName() const; std::string getFileName() const;
@@ -140,7 +141,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
bool getOverwriteEnable() const; bool getOverwriteEnable() const;
//***acquisition count parameters*** //***acquisition count parameters***
/** /**
* Get Total Frames Caught for an entire acquisition (including all scans) * Get Total Frames Caught for an entire acquisition (including all scans)
@@ -156,11 +156,11 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
/** /**
* Get Current Frame Index for an entire acquisition (including all scans) * Get Current Frame Index for an entire acquisition (including all scans)
* @return 0 if no frames have been caught, else average of all current frame index * @return 0 if no frames have been caught, else average of all current
* frame index
*/ */
uint64_t getAcquisitionIndex() const; uint64_t getAcquisitionIndex() const;
//***connection parameters*** //***connection parameters***
/** /**
* Get UDP Port Number * Get UDP Port Number
@@ -192,7 +192,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
int getNumberofUDPInterfaces() const; int getNumberofUDPInterfaces() const;
//***acquisition parameters*** //***acquisition parameters***
/** /**
* Get ROI * Get ROI
@@ -224,7 +223,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
bool getDataStreamEnable() const; bool getDataStreamEnable() const;
/** /**
* Get Acquisition Period * Get Acquisition Period
* @return acquisition period * @return acquisition period
@@ -251,19 +249,22 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
/* /*
* Get Number of Frames expected by receiver from detector * Get Number of Frames expected by receiver from detector
* The data receiver status will change from running to idle when it gets this number of frames FIXME: (Not implemented) * The data receiver status will change from running to idle when it gets
* this number of frames FIXME: (Not implemented)
* @return number of frames expected * @return number of frames expected
*/ */
uint64_t getNumberOfFrames() const; uint64_t getNumberOfFrames() const;
/* /*
* Get Number of Analog Samples expected by receiver from detector (for chip test board and moench only) * Get Number of Analog Samples expected by receiver from detector (for chip
* test board and moench only)
* @return number of Analog samples expected * @return number of Analog samples expected
*/ */
uint64_t getNumberofAnalogSamples() const; uint64_t getNumberofAnalogSamples() const;
/* /*
* Get Number of Digital Samples expected by receiver from detector (for chip test board and moench only) * Get Number of Digital Samples expected by receiver from detector (for
* chip test board and moench only)
* @return number of Digital samples expected * @return number of Digital samples expected
*/ */
uint64_t getNumberofDigitalSamples() const; uint64_t getNumberofDigitalSamples() const;
@@ -286,11 +287,11 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
uint32_t getFifoDepth() const; uint32_t getFifoDepth() const;
//***receiver status*** //***receiver status***
/** /**
* Get Listening Status of Receiver * Get Listening Status of Receiver
* @return can be idle, listening or error depending on if the receiver is listening or not * @return can be idle, listening or error depending on if the receiver is
* listening or not
*/ */
runStatus getStatus() const; runStatus getStatus() const;
@@ -314,16 +315,16 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
/** /**
* Get activate * Get activate
* If deactivated, receiver will create dummy data if deactivated padding is enabled * If deactivated, receiver will create dummy data if deactivated padding is
* (as it will receive nothing from detector) * enabled (as it will receive nothing from detector)
* @return false for deactivated, true for activated * @return false for deactivated, true for activated
*/ */
bool getActivate() const; bool getActivate() const;
/** /**
* Get deactivated padding enable * Get deactivated padding enable
* If enabled, receiver will create dummy packets (0xFF), else it will create nothing * If enabled, receiver will create dummy packets (0xFF), else it will
* (as it will receive nothing from detector) * create nothing (as it will receive nothing from detector)
* @return 0 for disabled, 1 for enabled * @return 0 for disabled, 1 for enabled
*/ */
bool getDeactivatedPadding() const; bool getDeactivatedPadding() const;
@@ -352,7 +353,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
int64_t getUDPSocketBufferSize() const; int64_t getUDPSocketBufferSize() const;
/** (not saved in client shared memory) /** (not saved in client shared memory)
* Get actual UDP Socket Buffer Size * Get actual UDP Socket Buffer Size
* @return actual UDP Socket Buffer Size * @return actual UDP Socket Buffer Size
@@ -397,7 +397,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
int setReadOutFlags(const readOutFlags f); int setReadOutFlags(const readOutFlags f);
//***file parameters*** //***file parameters***
/** /**
* Set File Format * Set File Format
@@ -406,8 +405,9 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
void setFileFormat(slsDetectorDefs::fileFormat f); void setFileFormat(slsDetectorDefs::fileFormat f);
/** /**
* Set File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw)) * Set File Name Prefix (without frame index, file index and extension
* Does not check for file existence since it is created only at startReceiver * (_d0_f000000000000_8.raw)) Does not check for file existence since it is
* created only at startReceiver
* @param c file name (max of 1000 characters) * @param c file name (max of 1000 characters)
*/ */
void setFileName(const char c[]); void setFileName(const char c[]);
@@ -501,7 +501,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
int setUDPSocketBufferSize(const int64_t s); int setUDPSocketBufferSize(const int64_t s);
//***acquisition parameters*** //***acquisition parameters***
/** /**
* Set ROI * Set ROI
@@ -583,7 +582,8 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
/** /**
* Set Number of Frames expected by receiver from detector * Set Number of Frames expected by receiver from detector
* The data receiver status will change from running to idle when it gets this number of frames * The data receiver status will change from running to idle when it gets
* this number of frames
* @param i number of frames expected * @param i number of frames expected
*/ */
void setNumberOfFrames(const uint64_t i); void setNumberOfFrames(const uint64_t i);
@@ -623,12 +623,11 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
int setFifoDepth(const uint32_t i); int setFifoDepth(const uint32_t i);
//***receiver parameters*** //***receiver parameters***
/** /**
* Activate / Deactivate Receiver * Activate / Deactivate Receiver
* If deactivated, receiver will create dummy data if deactivated padding is enabled * If deactivated, receiver will create dummy data if deactivated padding is
* (as it will receive nothing from detector) * enabled (as it will receive nothing from detector)
* @param enable enable * @param enable enable
* @return false for disabled, true for enabled * @return false for disabled, true for enabled
*/ */
@@ -636,8 +635,8 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
/** /**
* Set deactivated padding enable * Set deactivated padding enable
* If enabled, receiver will create dummy packets (0xFF), else it will create nothing * If enabled, receiver will create dummy packets (0xFF), else it will
* (as it will receive nothing from detector) * create nothing (as it will receive nothing from detector)
* @param enable enable * @param enable enable
* @return false for disabled, true for enabled * @return false for disabled, true for enabled
*/ */
@@ -661,7 +660,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/ */
void setDbitOffset(const int s); void setDbitOffset(const int s);
/************************************************************************* /*************************************************************************
* Behavioral functions*************************************************** * Behavioral functions***************************************************
* They may modify the status of the receiver **************************** * They may modify the status of the receiver ****************************
@@ -669,8 +667,9 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
//***initial functions*** //***initial functions***
/** /**
* Set receiver type (and corresponding detector variables in derived STANDARD class) * Set receiver type (and corresponding detector variables in derived
* It is the first function called by the client when connecting to receiver * STANDARD class) It is the first function called by the client when
* connecting to receiver
* @param d detector type * @param d detector type
* @return OK or FAIL * @return OK or FAIL
*/ */
@@ -684,13 +683,15 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
//***acquisition functions*** //***acquisition functions***
/** /**
* Reset acquisition parameters such as total frames caught for an entire acquisition (including all scans) * Reset acquisition parameters such as total frames caught for an entire
* acquisition (including all scans)
*/ */
void resetAcquisitionCount(); void resetAcquisitionCount();
/** /**
* Start Listening for Packets by activating all configuration settings to receiver * Start Listening for Packets by activating all configuration settings to
* When this function returns, it has status RUNNING(upon SUCCESS) or IDLE (upon failure) * receiver When this function returns, it has status RUNNING(upon SUCCESS)
* or IDLE (upon failure)
* @param c error message if FAIL * @param c error message if FAIL
* @return OK or FAIL * @return OK or FAIL
*/ */
@@ -698,20 +699,21 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
/** /**
* Stop Listening for Packets * Stop Listening for Packets
* Calls startReadout(), which stops listening and sets status to Transmitting * Calls startReadout(), which stops listening and sets status to
* When it has read every frame in buffer, the status changes to Run_Finished * Transmitting When it has read every frame in buffer, the status changes
* When this function returns, receiver has status IDLE * to Run_Finished When this function returns, receiver has status IDLE Pre:
* Pre: status is running, semaphores have been instantiated, * status is running, semaphores have been instantiated, Post: udp sockets
* Post: udp sockets shut down, status is idle, semaphores destroyed * shut down, status is idle, semaphores destroyed
*/ */
void stopReceiver(); void stopReceiver();
/** /**
* Stop Listening to Packets * Stop Listening to Packets
* and sets status to Transmitting * and sets status to Transmitting
* Next step would be to get all data and stop receiver completely and return with idle state * Next step would be to get all data and stop receiver completely and
* Pre: status is running, udp sockets have been initialized, stop receiver initiated * return with idle state Pre: status is running, udp sockets have been
* Post:udp sockets closed, status is transmitting * initialized, stop receiver initiated Post:udp sockets closed, status is
* transmitting
*/ */
void startReadout(); void startReadout();
@@ -745,14 +747,17 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
* we write depending on file write enable * we write depending on file write enable
* users get data to write depending on call backs registered * users get data to write depending on call backs registered
*/ */
void registerCallBackStartAcquisition(int (*func)(char*, char*, uint64_t, uint32_t, void*),void *arg); void registerCallBackStartAcquisition(int (*func)(char *, char *, uint64_t,
uint32_t, void *),
void *arg);
/** /**
* Call back for acquisition finished * Call back for acquisition finished
* callback argument is * callback argument is
* total frames caught * total frames caught
*/ */
void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void*),void *arg); void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *),
void *arg);
/** /**
* Call back for raw data * Call back for raw data
@@ -761,8 +766,9 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* dataSize in bytes is the size of the data in bytes. * dataSize in bytes is the size of the data in bytes.
*/ */
void registerCallBackRawDataReady(void (*func)(char* , void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t,
char*, uint32_t, void*),void *arg); void *),
void *arg);
/** /**
* Call back for raw data (modified) * Call back for raw data (modified)
@@ -770,13 +776,14 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
* sls_receiver_header frame metadata * sls_receiver_header frame metadata
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. * revDatasize is the reference of data size in bytes.
* Can be modified to the new size to be written/streamed. (only smaller value). * Can be modified to the new size to be written/streamed. (only smaller
* value).
*/ */
void registerCallBackRawDataModifyReady(void (*func)(char* , void registerCallBackRawDataModifyReady(void (*func)(char *, char *,
char*, uint32_t &,void*),void *arg); uint32_t &, void *),
void *arg);
private: private:
/** /**
* Delete and free member parameters * Delete and free member parameters
*/ */
@@ -829,8 +836,6 @@ private:
*/ */
void StartRunning(); void StartRunning();
/************************************************************************* /*************************************************************************
* Class Members ********************************************************* * Class Members *********************************************************
*************************************************************************/ *************************************************************************/
@@ -909,7 +914,8 @@ private:
//***file parameters*** //***file parameters***
/** File format */ /** File format */
fileFormat fileFormatType; fileFormat fileFormatType;
/** File Name without frame index, file index and extension (_d0_f000000000000_8.raw)*/ /** File Name without frame index, file index and extension
* (_d0_f000000000000_8.raw)*/
char fileName[MAX_STR_LENGTH]; char fileName[MAX_STR_LENGTH];
/** File Path */ /** File Path */
char filePath[MAX_STR_LENGTH]; char filePath[MAX_STR_LENGTH];
@@ -983,20 +989,16 @@ private:
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* dataSize in bytes is the size of the data in bytes. * dataSize in bytes is the size of the data in bytes.
*/ */
void (*rawDataReadyCallBack)(char* , void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *);
char*, uint32_t, void*);
/** /**
* Call back for raw data (modified) * Call back for raw data (modified)
* args to raw data ready callback are * args to raw data ready callback are
* sls_receiver_header frame metadata * sls_receiver_header frame metadata
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value). * revDatasize is the reference of data size in bytes. Can be modified to
* the new size to be written/streamed. (only smaller value).
*/ */
void (*rawDataModifyReadyCallBack)(char* , void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &, void *);
char*, uint32_t &, void*);
void *pRawDataReady; void *pRawDataReady;
}; };

61
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@@ -1,18 +1,18 @@
#pragma once #pragma once
/********************************************/ /** /********************************************/ /**
* @file slsReceiverTCPIPInterface.h * @file
* @short interface between receiver and client *slsReceiverTCPIPInterface.h
* @short interface between
*receiver and client
***********************************************/ ***********************************************/
#include "sls_detector_defs.h"
#include "receiver_defs.h" #include "receiver_defs.h"
#include "sls_detector_defs.h"
class MySocketTCP; class MySocketTCP;
class ServerInterface; class ServerInterface;
#include "slsReceiverImplementation.h"
#include "ServerSocket.h" #include "ServerSocket.h"
#include "slsReceiverImplementation.h"
/** /**
*@short interface between receiver and client *@short interface between receiver and client
@@ -23,7 +23,6 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
enum numberMode { DEC, HEX }; enum numberMode { DEC, HEX };
public: public:
/** Destructor */ /** Destructor */
virtual ~slsReceiverTCPIPInterface(); virtual ~slsReceiverTCPIPInterface();
@@ -45,7 +44,6 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
/** stop listening on the TCP & UDP port for client comminication */ /** stop listening on the TCP & UDP port for client comminication */
void stop(); void stop();
/** gets version */ /** gets version */
int64_t getReceiverVersion(); int64_t getReceiverVersion();
@@ -62,14 +60,17 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
* we write depending on file write enable * we write depending on file write enable
* users get data to write depending on call backs registered * users get data to write depending on call backs registered
*/ */
void registerCallBackStartAcquisition(int (*func)(char*, char*, uint64_t, uint32_t, void*),void *arg); void registerCallBackStartAcquisition(int (*func)(char *, char *, uint64_t,
uint32_t, void *),
void *arg);
/** /**
* Call back for acquisition finished * Call back for acquisition finished
* callback argument is * callback argument is
* total frames caught * total frames caught
*/ */
void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void*),void *arg); void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *),
void *arg);
/** /**
* Call back for raw data * Call back for raw data
@@ -78,8 +79,9 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* dataSize in bytes is the size of the data in bytes. * dataSize in bytes is the size of the data in bytes.
*/ */
void registerCallBackRawDataReady(void (*func)(char* , void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t,
char*, uint32_t, void*),void *arg); void *),
void *arg);
/** /**
* Call back for raw data (modified) * Call back for raw data (modified)
@@ -87,14 +89,14 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
* sls_receiver_header frame metadata * sls_receiver_header frame metadata
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. * revDatasize is the reference of data size in bytes.
* Can be modified to the new size to be written/streamed. (only smaller value). * Can be modified to the new size to be written/streamed. (only smaller
* value).
*/ */
void registerCallBackRawDataModifyReady(void (*func)(char* , void registerCallBackRawDataModifyReady(void (*func)(char *, char *,
char*, uint32_t &,void*),void *arg); uint32_t &, void *),
void *arg);
private: private:
/** /**
* Static function - Thread started which is a TCP server * Static function - Thread started which is a TCP server
* Called by start() * Called by start()
@@ -102,7 +104,6 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
*/ */
static void *startTCPServerThread(void *this_pointer); static void *startTCPServerThread(void *this_pointer);
/** /**
* Thread started which is a TCP server * Thread started which is a TCP server
* Called by start() * Called by start()
@@ -300,7 +301,8 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
std::unique_ptr<slsReceiverImplementation> receiver{nullptr}; std::unique_ptr<slsReceiverImplementation> receiver{nullptr};
/** Function List */ /** Function List */
int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(sls::ServerInterface2& socket); int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(
sls::ServerInterface2 &socket);
/** Message */ /** Message */
char mess[MAX_STR_LENGTH]{}; char mess[MAX_STR_LENGTH]{};
@@ -339,7 +341,8 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
* we write depending on file write enable * we write depending on file write enable
* users get data to write depending on call backs registered * users get data to write depending on call backs registered
*/ */
int (*startAcquisitionCallBack)(char*, char*, uint64_t, uint32_t, void*) = nullptr; int (*startAcquisitionCallBack)(char *, char *, uint64_t, uint32_t,
void *) = nullptr;
void *pStartAcquisition{nullptr}; void *pStartAcquisition{nullptr};
/** /**
@@ -350,7 +353,6 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
void (*acquisitionFinishedCallBack)(uint64_t, void *) = nullptr; void (*acquisitionFinishedCallBack)(uint64_t, void *) = nullptr;
void *pAcquisitionFinished{nullptr}; void *pAcquisitionFinished{nullptr};
/** /**
* Call back for raw data * Call back for raw data
* args to raw data ready callback are * args to raw data ready callback are
@@ -358,26 +360,22 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* dataSize in bytes is the size of the data in bytes. * dataSize in bytes is the size of the data in bytes.
*/ */
void (*rawDataReadyCallBack)(char* , void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *) = nullptr;
char*, uint32_t, void*) = nullptr;
/** /**
* Call back for raw data (modified) * Call back for raw data (modified)
* args to raw data ready callback are * args to raw data ready callback are
* sls_receiver_header frame metadata * sls_receiver_header frame metadata
* dataPointer is the pointer to the data * dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value). * revDatasize is the reference of data size in bytes. Can be modified to
* the new size to be written/streamed. (only smaller value).
*/ */
void (*rawDataModifyReadyCallBack)(char* , void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &,
char*, uint32_t &, void*) = nullptr; void *) = nullptr;
void *pRawDataReady{nullptr}; void *pRawDataReady{nullptr};
protected: protected:
std::unique_ptr<sls::ServerSocket> server{nullptr}; std::unique_ptr<sls::ServerSocket> server{nullptr};
private: private:
@@ -388,7 +386,8 @@ protected:
if (receiver != nullptr) { if (receiver != nullptr) {
return receiver.get(); return receiver.get();
} else { } else {
throw sls::SocketError("Receiver not set up. Please use rx_hostname first.\n"); throw sls::SocketError(
"Receiver not set up. Please use rx_hostname first.\n");
} }
} }
}; };

447
slsReceiverSoftware/src/slsReceiverImplementation.cpp
View File

File diff suppressed because it is too large Load Diff

223
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@@ -1,18 +1,19 @@
/********************************************/ /** /********************************************/ /**
* @file slsReceiverTCPIPInterface.cpp * @file
* @short interface between receiver and client *slsReceiverTCPIPInterface.cpp
* @short interface between
*receiver and client
***********************************************/ ***********************************************/
#include "slsReceiverTCPIPInterface.h"
#include "FixedCapacityContainer.h" #include "FixedCapacityContainer.h"
#include "ServerSocket.h" #include "ServerSocket.h"
#include "slsReceiver.h" #include "slsReceiver.h"
#include "slsReceiverImplementation.h" #include "slsReceiverImplementation.h"
#include "slsReceiverTCPIPInterface.h"
#include "slsReceiverUsers.h" #include "slsReceiverUsers.h"
#include "versionAPI.h"
#include "string_utils.h"
#include "sls_detector_exceptions.h" #include "sls_detector_exceptions.h"
#include "string_utils.h"
#include "versionAPI.h"
#include <array> #include <array>
#include <cstdlib> #include <cstdlib>
@@ -24,26 +25,22 @@
#include <syscall.h> #include <syscall.h>
#include <vector> #include <vector>
using sls::SocketError;
using sls::RuntimeError; using sls::RuntimeError;
using sls::SocketError;
using Interface = sls::ServerInterface2; using Interface = sls::ServerInterface2;
slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { stop(); }
stop();
}
slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int pn): slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int pn)
myDetectorType(GOTTHARD), : myDetectorType(GOTTHARD), portNumber(pn > 0 ? pn : DEFAULT_PORTNO + 2) {
portNumber(pn > 0 ? pn : DEFAULT_PORTNO + 2)
{
function_table(); function_table();
} }
int slsReceiverTCPIPInterface::start() { int slsReceiverTCPIPInterface::start() {
FILE_LOG(logDEBUG) << "Creating TCP Server Thread"; FILE_LOG(logDEBUG) << "Creating TCP Server Thread";
killTCPServerThread = 0; killTCPServerThread = 0;
if(pthread_create(&TCPServer_thread, nullptr,startTCPServerThread, (void*) this)){ if (pthread_create(&TCPServer_thread, nullptr, startTCPServerThread,
(void *)this)) {
FILE_LOG(logERROR) << "Could not create TCP Server thread"; FILE_LOG(logERROR) << "Could not create TCP Server thread";
return FAIL; return FAIL;
} }
@@ -52,7 +49,6 @@ int slsReceiverTCPIPInterface::start(){
return OK; return OK;
} }
void slsReceiverTCPIPInterface::stop() { void slsReceiverTCPIPInterface::stop() {
if (tcpThreadCreated) { if (tcpThreadCreated) {
FILE_LOG(logINFO) << "Shutting down TCP Socket on port " << portNumber; FILE_LOG(logINFO) << "Shutting down TCP Socket on port " << portNumber;
@@ -63,35 +59,34 @@ void slsReceiverTCPIPInterface::stop(){
pthread_join(TCPServer_thread, nullptr); pthread_join(TCPServer_thread, nullptr);
tcpThreadCreated = false; tcpThreadCreated = false;
killTCPServerThread = 0; killTCPServerThread = 0;
FILE_LOG(logDEBUG) << "Exiting TCP Server Thread on port " << portNumber; FILE_LOG(logDEBUG) << "Exiting TCP Server Thread on port "
<< portNumber;
} }
} }
int64_t slsReceiverTCPIPInterface::getReceiverVersion() { return APIRECEIVER; }
int64_t slsReceiverTCPIPInterface::getReceiverVersion(){
return APIRECEIVER;
}
/***callback functions***/ /***callback functions***/
void slsReceiverTCPIPInterface::registerCallBackStartAcquisition(int (*func)(char*, char*, uint64_t, uint32_t, void*),void *arg){ void slsReceiverTCPIPInterface::registerCallBackStartAcquisition(
int (*func)(char *, char *, uint64_t, uint32_t, void *), void *arg) {
startAcquisitionCallBack = func; startAcquisitionCallBack = func;
pStartAcquisition = arg; pStartAcquisition = arg;
} }
void slsReceiverTCPIPInterface::registerCallBackAcquisitionFinished(void (*func)(uint64_t, void*),void *arg){ void slsReceiverTCPIPInterface::registerCallBackAcquisitionFinished(
void (*func)(uint64_t, void *), void *arg) {
acquisitionFinishedCallBack = func; acquisitionFinishedCallBack = func;
pAcquisitionFinished = arg; pAcquisitionFinished = arg;
} }
void slsReceiverTCPIPInterface::registerCallBackRawDataReady(void (*func)(char* , void slsReceiverTCPIPInterface::registerCallBackRawDataReady(
char*, uint32_t, void*),void *arg){ void (*func)(char *, char *, uint32_t, void *), void *arg) {
rawDataReadyCallBack = func; rawDataReadyCallBack = func;
pRawDataReady = arg; pRawDataReady = arg;
} }
void slsReceiverTCPIPInterface::registerCallBackRawDataModifyReady(void (*func)(char* , void slsReceiverTCPIPInterface::registerCallBackRawDataModifyReady(
char*, uint32_t &,void*),void *arg){ void (*func)(char *, char *, uint32_t &, void *), void *arg) {
rawDataModifyReadyCallBack = func; rawDataModifyReadyCallBack = func;
pRawDataReady = arg; pRawDataReady = arg;
} }
@@ -102,8 +97,8 @@ void* slsReceiverTCPIPInterface::startTCPServerThread(void *this_pointer){
} }
void slsReceiverTCPIPInterface::startTCPServer() { void slsReceiverTCPIPInterface::startTCPServer() {
FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " << syscall(SYS_gettid)
<< syscall(SYS_gettid) << "]"; << "]";
FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port " FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port "
<< portNumber << '\n'; << portNumber << '\n';
server = sls::make_unique<sls::ServerSocket>(portNumber); server = sls::make_unique<sls::ServerSocket>(portNumber);
@@ -122,7 +117,6 @@ void slsReceiverTCPIPInterface::startTCPServer() {
socket.write(mess, sizeof(mess)); socket.write(mess, sizeof(mess));
} }
// if tcp command was to exit server // if tcp command was to exit server
if (ret == GOODBYE) { if (ret == GOODBYE) {
FILE_LOG(logINFO) << "Shutting down UDP Socket"; FILE_LOG(logINFO) << "Shutting down UDP Socket";
@@ -151,7 +145,7 @@ void slsReceiverTCPIPInterface::startTCPServer() {
} }
} }
} }
// clang-format off
int slsReceiverTCPIPInterface::function_table(){ int slsReceiverTCPIPInterface::function_table(){
flist[F_EXEC_RECEIVER_COMMAND] = &slsReceiverTCPIPInterface::exec_command; flist[F_EXEC_RECEIVER_COMMAND] = &slsReceiverTCPIPInterface::exec_command;
flist[F_EXIT_RECEIVER] = &slsReceiverTCPIPInterface::exit_server; flist[F_EXIT_RECEIVER] = &slsReceiverTCPIPInterface::exit_server;
@@ -215,7 +209,7 @@ int slsReceiverTCPIPInterface::function_table(){
return OK; return OK;
} }
// clang-format on
int slsReceiverTCPIPInterface::decode_function(Interface &socket) { int slsReceiverTCPIPInterface::decode_function(Interface &socket) {
ret = FAIL; ret = FAIL;
socket.receiveArg(fnum); socket.receiveArg(fnum);
@@ -241,14 +235,17 @@ void slsReceiverTCPIPInterface::functionNotImplemented() {
throw RuntimeError(mess); throw RuntimeError(mess);
} }
void slsReceiverTCPIPInterface::modeNotImplemented(std::string modename, int mode) { void slsReceiverTCPIPInterface::modeNotImplemented(std::string modename,
int mode) {
char message[MAX_STR_LENGTH]; char message[MAX_STR_LENGTH];
sprintf(message, "%s (%d) is not implemented for this detector\n", modename.c_str(), mode); sprintf(message, "%s (%d) is not implemented for this detector\n",
modename.c_str(), mode);
throw RuntimeError(message); throw RuntimeError(message);
} }
template <typename T> template <typename T>
void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename, numberMode hex) { void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename,
numberMode hex) {
if (ret == OK && arg != -1 && retval != arg) { if (ret == OK && arg != -1 && retval != arg) {
if (hex) if (hex)
sprintf(mess, "Could not %s. Set 0x%x, but read 0x%x\n", sprintf(mess, "Could not %s. Set 0x%x, but read 0x%x\n",
@@ -325,11 +322,11 @@ int slsReceiverTCPIPInterface::get_last_client_ip(Interface &socket) {
return socket.sendResult(ret, &ip, sizeof(ip)); return socket.sendResult(ret, &ip, sizeof(ip));
} }
int slsReceiverTCPIPInterface::set_port(Interface &socket) { int slsReceiverTCPIPInterface::set_port(Interface &socket) {
auto p_number = socket.receive<int>(); auto p_number = socket.receive<int>();
if (p_number < 1024) if (p_number < 1024)
throw RuntimeError("Port Number: " + std::to_string(p_number)+ " is too low (<1024)"); throw RuntimeError("Port Number: " + std::to_string(p_number) +
" is too low (<1024)");
FILE_LOG(logINFO) << "set port to " << p_number << std::endl; FILE_LOG(logINFO) << "set port to " << p_number << std::endl;
auto new_server = sls::make_unique<sls::ServerSocket>(p_number); auto new_server = sls::make_unique<sls::ServerSocket>(p_number);
@@ -342,13 +339,12 @@ int slsReceiverTCPIPInterface::set_port(Interface &socket) {
int slsReceiverTCPIPInterface::update_client(Interface &socket) { int slsReceiverTCPIPInterface::update_client(Interface &socket) {
if (receiver == nullptr) if (receiver == nullptr)
throw sls::SocketError("Receiver not set up. Please use rx_hostname first.\n"); throw sls::SocketError(
"Receiver not set up. Please use rx_hostname first.\n");
socket.sendData(OK); socket.sendData(OK);
return send_update(socket); return send_update(socket);
} }
int slsReceiverTCPIPInterface::send_update(Interface &socket) { int slsReceiverTCPIPInterface::send_update(Interface &socket) {
int n = 0; int n = 0;
int i32 = -1; int i32 = -1;
@@ -459,7 +455,8 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket){
auto arg = socket.receive<detectorType>(); auto arg = socket.receive<detectorType>();
// set // set
if (arg >= 0) { if (arg >= 0) {
// if object exists, verify unlocked and idle, else only verify lock (connecting first time) // if object exists, verify unlocked and idle, else only verify lock
// (connecting first time)
if (receiver != nullptr) { if (receiver != nullptr) {
VerifyIdle(socket); VerifyIdle(socket);
} }
@@ -485,14 +482,17 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket){
// callbacks after (in setdetectortype, the object is reinitialized) // callbacks after (in setdetectortype, the object is reinitialized)
if (startAcquisitionCallBack) if (startAcquisitionCallBack)
impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,pStartAcquisition); impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,
pStartAcquisition);
if (acquisitionFinishedCallBack) if (acquisitionFinishedCallBack)
impl()->registerCallBackAcquisitionFinished(acquisitionFinishedCallBack,pAcquisitionFinished); impl()->registerCallBackAcquisitionFinished(
acquisitionFinishedCallBack, pAcquisitionFinished);
if (rawDataReadyCallBack) if (rawDataReadyCallBack)
impl()->registerCallBackRawDataReady(rawDataReadyCallBack,pRawDataReady); impl()->registerCallBackRawDataReady(rawDataReadyCallBack,
pRawDataReady);
if (rawDataModifyReadyCallBack) if (rawDataModifyReadyCallBack)
impl()->registerCallBackRawDataModifyReady(rawDataModifyReadyCallBack,pRawDataReady); impl()->registerCallBackRawDataModifyReady(
rawDataModifyReadyCallBack, pRawDataReady);
} }
return socket.sendResult(myDetectorType); return socket.sendResult(myDetectorType);
} }
@@ -514,7 +514,6 @@ int slsReceiverTCPIPInterface::set_detector_hostname(Interface &socket) {
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::set_roi(Interface &socket) { int slsReceiverTCPIPInterface::set_roi(Interface &socket) {
static_assert(sizeof(ROI) == 4 * sizeof(int), "ROI not packed"); static_assert(sizeof(ROI) == 4 * sizeof(int), "ROI not packed");
auto narg = socket.receive<int>(); auto narg = socket.receive<int>();
@@ -526,9 +525,9 @@ int slsReceiverTCPIPInterface::set_roi(Interface &socket) {
} }
FILE_LOG(logDEBUG1) << "Set ROI narg: " << narg; FILE_LOG(logDEBUG1) << "Set ROI narg: " << narg;
for (int iloop = 0; iloop < narg; ++iloop) { for (int iloop = 0; iloop < narg; ++iloop) {
FILE_LOG(logDEBUG1) << "(" << arg[iloop].xmin << ", " << FILE_LOG(logDEBUG1)
arg[iloop].xmax << ", " << arg[iloop].ymin << ", " << << "(" << arg[iloop].xmin << ", " << arg[iloop].xmax << ", "
arg[iloop].ymax << ")"; << arg[iloop].ymin << ", " << arg[iloop].ymax << ")";
} }
if (myDetectorType == EIGER || myDetectorType == JUNGFRAU) if (myDetectorType == EIGER || myDetectorType == JUNGFRAU)
@@ -570,7 +569,8 @@ int slsReceiverTCPIPInterface::setup_udp(Interface &socket){
// if there is a dot in eth name // if there is a dot in eth name
if (strchr(eth, '.') != nullptr) { if (strchr(eth, '.') != nullptr) {
strcpy(eth, ""); strcpy(eth, "");
sprintf(mess, "Failed to get ethernet interface from IP. Got %s\n", temp.c_str()); sprintf(mess, "Failed to get ethernet interface from IP. Got %s\n",
temp.c_str());
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} }
impl()->setEthernetInterface(eth); impl()->setEthernetInterface(eth);
@@ -604,7 +604,10 @@ int slsReceiverTCPIPInterface::setup_udp(Interface &socket){
// if there is a dot in eth name // if there is a dot in eth name
if (strchr(eth, '.') != nullptr) { if (strchr(eth, '.') != nullptr) {
strcpy(eth, ""); strcpy(eth, "");
sprintf(mess, "Failed to get 2nd ethernet interface from IP. Got %s\n", temp.c_str()); sprintf(
mess,
"Failed to get 2nd ethernet interface from IP. Got %s\n",
temp.c_str());
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} }
impl()->setEthernetInterface2(eth); impl()->setEthernetInterface2(eth);
@@ -613,18 +616,22 @@ int slsReceiverTCPIPInterface::setup_udp(Interface &socket){
if (ret != FAIL) { if (ret != FAIL) {
temp = sls::InterfaceNameToMac(eth).str(); temp = sls::InterfaceNameToMac(eth).str();
if (temp == "00:00:00:00:00:00") { if (temp == "00:00:00:00:00:00") {
throw RuntimeError("failed to get 2nd mac adddress to listen to"); throw RuntimeError(
"failed to get 2nd mac adddress to listen to");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} else { } else {
strcpy(retvals[1], temp.c_str()); strcpy(retvals[1], temp.c_str());
FILE_LOG(logINFO) << "Receiver MAC Address 2: " << retvals[1]; FILE_LOG(logINFO)
<< "Receiver MAC Address 2: " << retvals[1];
} }
} }
} }
} }
// set the number of udp interfaces (changes number of threads and many others) // set the number of udp interfaces (changes number of threads and many
if (myDetectorType == JUNGFRAU && impl()->setNumberofUDPInterfaces(numInterfaces) == FAIL) { // others)
if (myDetectorType == JUNGFRAU &&
impl()->setNumberofUDPInterfaces(numInterfaces) == FAIL) {
throw RuntimeError("Failed to set number of interfaces"); throw RuntimeError("Failed to set number of interfaces");
} }
return socket.sendResult(ret, retvals, sizeof(retvals), mess); return socket.sendResult(ret, retvals, sizeof(retvals), mess);
@@ -636,7 +643,8 @@ int slsReceiverTCPIPInterface::set_timer(Interface &socket) {
int64_t retval = -1; int64_t retval = -1;
socket.receiveArg(index); socket.receiveArg(index);
if (index[1] >= 0) { if (index[1] >= 0) {
FILE_LOG(logDEBUG1) << "Setting timer index " << index[0] << " to " << index[1]; FILE_LOG(logDEBUG1)
<< "Setting timer index " << index[0] << " to " << index[1];
switch (index[0]) { switch (index[0]) {
case ACQUISITION_TIME: case ACQUISITION_TIME:
ret = impl()->setAcquisitionTime(index[1]); ret = impl()->setAcquisitionTime(index[1]);
@@ -657,14 +665,16 @@ int slsReceiverTCPIPInterface::set_timer(Interface &socket) {
break; break;
case ANALOG_SAMPLES: case ANALOG_SAMPLES:
if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) { if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) {
modeNotImplemented("(Analog Samples) Timer index", (int)index[0]); modeNotImplemented("(Analog Samples) Timer index",
(int)index[0]);
break; break;
} }
impl()->setNumberofAnalogSamples(index[1]); impl()->setNumberofAnalogSamples(index[1]);
break; break;
case DIGITAL_SAMPLES: case DIGITAL_SAMPLES:
if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) { if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) {
modeNotImplemented("(Digital Samples) Timer index", (int)index[0]); modeNotImplemented("(Digital Samples) Timer index",
(int)index[0]);
break; break;
} }
impl()->setNumberofDigitalSamples(index[1]); impl()->setNumberofDigitalSamples(index[1]);
@@ -673,7 +683,6 @@ int slsReceiverTCPIPInterface::set_timer(Interface &socket) {
modeNotImplemented("Timer index", (int)index[0]); modeNotImplemented("Timer index", (int)index[0]);
break; break;
} }
} }
// get // get
switch (index[0]) { switch (index[0]) {
@@ -696,14 +705,20 @@ int slsReceiverTCPIPInterface::set_timer(Interface &socket) {
break; break;
case ANALOG_SAMPLES: case ANALOG_SAMPLES:
if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) { if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) {
sprintf(mess,"This timer mode (%lld) does not exist for this receiver type\n", (long long int)index[0]); sprintf(mess,
"This timer mode (%lld) does not exist for this receiver "
"type\n",
(long long int)index[0]);
throw RuntimeError(mess); throw RuntimeError(mess);
} }
retval = impl()->getNumberofAnalogSamples(); retval = impl()->getNumberofAnalogSamples();
break; break;
case DIGITAL_SAMPLES: case DIGITAL_SAMPLES:
if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) { if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) {
sprintf(mess,"This timer mode (%lld) does not exist for this receiver type\n", (long long int)index[0]); sprintf(mess,
"This timer mode (%lld) does not exist for this receiver "
"type\n",
(long long int)index[0]);
throw RuntimeError(mess); throw RuntimeError(mess);
} }
retval = impl()->getNumberofDigitalSamples(); retval = impl()->getNumberofDigitalSamples();
@@ -713,7 +728,8 @@ int slsReceiverTCPIPInterface::set_timer(Interface &socket) {
break; break;
} }
validate((int)index[1], (int)retval, std::string("set timer"), DEC); validate((int)index[1], (int)retval, std::string("set timer"), DEC);
FILE_LOG(logDEBUG1) << slsDetectorDefs::getTimerType((timerIndex)(index[0])) << ":" << retval; FILE_LOG(logDEBUG1) << slsDetectorDefs::getTimerType((timerIndex)(index[0]))
<< ":" << retval;
return socket.sendResult(retval); return socket.sendResult(retval);
} }
@@ -738,14 +754,13 @@ int slsReceiverTCPIPInterface::set_dynamic_range(Interface &socket) {
} }
if (!exists) { if (!exists) {
modeNotImplemented("Dynamic range", dr); modeNotImplemented("Dynamic range", dr);
} } else {
else {
ret = impl()->setDynamicRange(dr); ret = impl()->setDynamicRange(dr);
if (ret == FAIL) { if (ret == FAIL) {
throw RuntimeError("Could not allocate memory for fifo or could not start listening/writing threads"); throw RuntimeError("Could not allocate memory for fifo or "
"could not start listening/writing threads");
} }
} }
} }
int retval = impl()->getDynamicRange(); int retval = impl()->getDynamicRange();
validate(dr, retval, std::string("set dynamic range"), DEC); validate(dr, retval, std::string("set dynamic range"), DEC);
@@ -777,7 +792,8 @@ int slsReceiverTCPIPInterface::get_status(Interface &socket){
int slsReceiverTCPIPInterface::start_receiver(Interface &socket) { int slsReceiverTCPIPInterface::start_receiver(Interface &socket) {
runStatus status = impl()->getStatus(); runStatus status = impl()->getStatus();
if (status != IDLE) { if (status != IDLE) {
throw RuntimeError("Cannot start Receiver as it is: " +runStatusType(status)); throw RuntimeError("Cannot start Receiver as it is: " +
runStatusType(status));
} else { } else {
FILE_LOG(logDEBUG1) << "Starting Receiver"; FILE_LOG(logDEBUG1) << "Starting Receiver";
ret = impl()->startReceiver(mess); ret = impl()->startReceiver(mess);
@@ -795,7 +811,8 @@ int slsReceiverTCPIPInterface::stop_receiver(Interface &socket){
} }
auto s = impl()->getStatus(); auto s = impl()->getStatus();
if (s != IDLE) if (s != IDLE)
throw RuntimeError("Could not stop receiver. It as it is: " + runStatusType(s)); throw RuntimeError("Could not stop receiver. It as it is: " +
runStatusType(s));
return socket.sendData(OK); return socket.sendData(OK);
} }
@@ -880,7 +897,6 @@ int slsReceiverTCPIPInterface::enable_file_write(Interface &socket){
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket) { int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket) {
auto enable = socket.receive<int>(); auto enable = socket.receive<int>();
if (enable >= 0) { if (enable >= 0) {
@@ -894,7 +910,6 @@ int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket){
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) { int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) {
auto index = socket.receive<int>(); auto index = socket.receive<int>();
if (index >= 0) { if (index >= 0) {
@@ -910,14 +925,14 @@ int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) {
int slsReceiverTCPIPInterface::enable_tengiga(Interface &socket) { int slsReceiverTCPIPInterface::enable_tengiga(Interface &socket) {
auto val = socket.receive<int>(); auto val = socket.receive<int>();
if (myDetectorType != EIGER && myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) if (myDetectorType != EIGER && myDetectorType != CHIPTESTBOARD &&
myDetectorType != MOENCH)
functionNotImplemented(); functionNotImplemented();
if (val >= 0) { if (val >= 0) {
VerifyIdle(socket); VerifyIdle(socket);
FILE_LOG(logDEBUG1) << "Setting 10GbE:" << val; FILE_LOG(logDEBUG1) << "Setting 10GbE:" << val;
ret = impl()->setTenGigaEnable(val); ret = impl()->setTenGigaEnable(val);
} }
int retval = impl()->getTenGigaEnable(); int retval = impl()->getTenGigaEnable();
validate(val, retval, std::string("set 10GbE"), DEC); validate(val, retval, std::string("set 10GbE"), DEC);
@@ -967,8 +982,6 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(Interface &socket){
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket) { int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket) {
auto index = socket.receive<int>(); auto index = socket.receive<int>();
if (index >= 0) { if (index >= 0) {
@@ -982,8 +995,6 @@ int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket){
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket) { int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket) {
// TODO! Why 2 args? // TODO! Why 2 args?
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
@@ -1004,8 +1015,6 @@ int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket){
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::set_file_format(Interface &socket) { int slsReceiverTCPIPInterface::set_file_format(Interface &socket) {
fileFormat f = GET_FILE_FORMAT; fileFormat f = GET_FILE_FORMAT;
socket.receiveArg(f); socket.receiveArg(f);
@@ -1038,9 +1047,9 @@ int slsReceiverTCPIPInterface::set_multi_detector_size(Interface &socket) {
socket.receiveArg(arg); socket.receiveArg(arg);
if ((arg[0] > 0) && (arg[1] > 0)) { if ((arg[0] > 0) && (arg[1] > 0)) {
VerifyIdle(socket); VerifyIdle(socket);
FILE_LOG(logDEBUG1) << "Setting multi detector size:" << arg[0] << "," << arg[1]; FILE_LOG(logDEBUG1)
<< "Setting multi detector size:" << arg[0] << "," << arg[1];
impl()->setMultiDetectorSize(arg); impl()->setMultiDetectorSize(arg);
} }
int *temp = impl()->getMultiDetectorSize(); // TODO! return by value! int *temp = impl()->getMultiDetectorSize(); // TODO! return by value!
int retval = temp[0] * temp[1]; int retval = temp[0] * temp[1];
@@ -1105,7 +1114,8 @@ int slsReceiverTCPIPInterface::enable_gap_pixels(Interface &socket) {
int slsReceiverTCPIPInterface::restream_stop(Interface &socket) { int slsReceiverTCPIPInterface::restream_stop(Interface &socket) {
VerifyIdle(socket); VerifyIdle(socket);
if (impl()->getDataStreamEnable() == false) { if (impl()->getDataStreamEnable() == false) {
throw RuntimeError("Could not restream stop packet as data Streaming is disabled"); throw RuntimeError(
"Could not restream stop packet as data Streaming is disabled");
} else { } else {
FILE_LOG(logDEBUG1) << "Restreaming stop"; FILE_LOG(logDEBUG1) << "Restreaming stop";
ret = impl()->restreamStop(); ret = impl()->restreamStop();
@@ -1141,17 +1151,23 @@ int slsReceiverTCPIPInterface::set_udp_socket_buffer_size(Interface &socket) {
VerifyIdle(socket); VerifyIdle(socket);
FILE_LOG(logDEBUG1) << "Setting UDP Socket Buffer size: " << index; FILE_LOG(logDEBUG1) << "Setting UDP Socket Buffer size: " << index;
if (impl()->setUDPSocketBufferSize(index) == FAIL) { if (impl()->setUDPSocketBufferSize(index) == FAIL) {
throw RuntimeError("Could not create dummy UDP Socket to test buffer size"); throw RuntimeError(
"Could not create dummy UDP Socket to test buffer size");
} }
} }
int64_t retval = impl()->getUDPSocketBufferSize(); int64_t retval = impl()->getUDPSocketBufferSize();
if (index != 0) if (index != 0)
validate(index, retval, std::string("set udp socket buffer size (No CAP_NET_ADMIN privileges?)"), DEC); validate(
index, retval,
std::string(
"set udp socket buffer size (No CAP_NET_ADMIN privileges?)"),
DEC);
FILE_LOG(logDEBUG1) << "UDP Socket Buffer Size:" << retval; FILE_LOG(logDEBUG1) << "UDP Socket Buffer Size:" << retval;
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size(Interface &socket){ int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size(
Interface &socket) {
auto size = impl()->getActualUDPSocketBufferSize(); auto size = impl()->getActualUDPSocketBufferSize();
FILE_LOG(logDEBUG1) << "Actual UDP socket size :" << size; FILE_LOG(logDEBUG1) << "Actual UDP socket size :" << size;
return socket.sendResult(size); return socket.sendResult(size);
@@ -1172,7 +1188,8 @@ int slsReceiverTCPIPInterface::set_frames_per_file(Interface &socket) {
int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) { int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) {
auto arg = socket.receive<int64_t>(); auto arg = socket.receive<int64_t>();
FILE_LOG(logDEBUG1) << "Checking versioning compatibility with value " << arg; FILE_LOG(logDEBUG1) << "Checking versioning compatibility with value "
<< arg;
int64_t client_requiredVersion = arg; int64_t client_requiredVersion = arg;
int64_t rx_apiVersion = APIRECEIVER; int64_t rx_apiVersion = APIRECEIVER;
int64_t rx_version = getReceiverVersion(); int64_t rx_version = getReceiverVersion();
@@ -1180,8 +1197,10 @@ int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) {
if (rx_apiVersion > client_requiredVersion) { if (rx_apiVersion > client_requiredVersion) {
// old client // old client
ret = FAIL; ret = FAIL;
sprintf(mess,"This client is incompatible.\n" sprintf(mess,
"Client's receiver API Version: (0x%llx). Receiver API Version: (0x%llx).\n" "This client is incompatible.\n"
"Client's receiver API Version: (0x%llx). Receiver API "
"Version: (0x%llx).\n"
"Incompatible, update client!\n", "Incompatible, update client!\n",
(long long unsigned int)client_requiredVersion, (long long unsigned int)client_requiredVersion,
(long long unsigned int)rx_apiVersion); (long long unsigned int)rx_apiVersion);
@@ -1189,14 +1208,15 @@ int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) {
} else if (client_requiredVersion > rx_version) { } else if (client_requiredVersion > rx_version) {
// old software // old software
ret = FAIL; ret = FAIL;
sprintf(mess,"This receiver is incompatible.\n" sprintf(mess,
"Receiver Version: (0x%llx). Client's receiver API Version: (0x%llx).\n" "This receiver is incompatible.\n"
"Receiver Version: (0x%llx). Client's receiver API Version: "
"(0x%llx).\n"
"Incompatible, update receiver!\n", "Incompatible, update receiver!\n",
(long long unsigned int)rx_version, (long long unsigned int)rx_version,
(long long unsigned int)client_requiredVersion); (long long unsigned int)client_requiredVersion);
throw RuntimeError(mess); throw RuntimeError(mess);
} } else {
else{
FILE_LOG(logINFO) << "Compatibility with Client: Successful"; FILE_LOG(logINFO) << "Compatibility with Client: Successful";
} }
return socket.sendData(OK); return socket.sendData(OK);
@@ -1229,7 +1249,8 @@ int slsReceiverTCPIPInterface::set_padding_enable(Interface &socket) {
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int slsReceiverTCPIPInterface::set_deactivated_padding_enable(Interface &socket) { int slsReceiverTCPIPInterface::set_deactivated_padding_enable(
Interface &socket) {
auto enable = socket.receive<int>(); auto enable = socket.receive<int>();
if (myDetectorType != EIGER) if (myDetectorType != EIGER)
functionNotImplemented(); functionNotImplemented();
@@ -1240,7 +1261,8 @@ int slsReceiverTCPIPInterface::set_deactivated_padding_enable(Interface &socket)
impl()->setDeactivatedPadding(enable > 0 ? true : false); impl()->setDeactivatedPadding(enable > 0 ? true : false);
} }
auto retval = static_cast<int>(impl()->getDeactivatedPadding()); auto retval = static_cast<int>(impl()->getDeactivatedPadding());
validate(enable, retval, std::string("set deactivated padding enable"), DEC); validate(enable, retval, std::string("set deactivated padding enable"),
DEC);
FILE_LOG(logDEBUG1) << "Deactivated Padding Enable: " << retval; FILE_LOG(logDEBUG1) << "Deactivated Padding Enable: " << retval;
return socket.sendResult(retval); return socket.sendResult(retval);
} }
@@ -1248,7 +1270,8 @@ int slsReceiverTCPIPInterface::set_deactivated_padding_enable(Interface &socket)
int slsReceiverTCPIPInterface::set_readout_flags(Interface &socket) { int slsReceiverTCPIPInterface::set_readout_flags(Interface &socket) {
auto arg = socket.receive<readOutFlags>(); auto arg = socket.receive<readOutFlags>();
if (myDetectorType == JUNGFRAU || myDetectorType == GOTTHARD || myDetectorType == MOENCH) if (myDetectorType == JUNGFRAU || myDetectorType == GOTTHARD ||
myDetectorType == MOENCH)
functionNotImplemented(); functionNotImplemented();
if (arg >= 0) { if (arg >= 0) {
@@ -1257,7 +1280,8 @@ int slsReceiverTCPIPInterface::set_readout_flags(Interface &socket) {
ret = impl()->setReadOutFlags(arg); ret = impl()->setReadOutFlags(arg);
} }
auto retval = impl()->getReadOutFlags(); auto retval = impl()->getReadOutFlags();
validate((int)arg, (int)(retval & arg), std::string("set readout flags"), HEX); validate((int)arg, (int)(retval & arg), std::string("set readout flags"),
HEX);
FILE_LOG(logDEBUG1) << "Readout flags: " << retval; FILE_LOG(logDEBUG1) << "Readout flags: " << retval;
return socket.sendResult(retval); return socket.sendResult(retval);
} }
@@ -1269,7 +1293,8 @@ int slsReceiverTCPIPInterface::set_adc_mask(Interface &socket) {
impl()->setADCEnableMask(arg); impl()->setADCEnableMask(arg);
auto retval = impl()->getADCEnableMask(); auto retval = impl()->getADCEnableMask();
if (retval != arg) { if (retval != arg) {
sprintf(mess, "Could not ADC enable mask. Set 0x%x, but read 0x%x\n", arg, retval); sprintf(mess, "Could not ADC enable mask. Set 0x%x, but read 0x%x\n",
arg, retval);
throw RuntimeError(mess); throw RuntimeError(mess);
} }
FILE_LOG(logDEBUG1) << "ADC enable mask retval: " << retval; FILE_LOG(logDEBUG1) << "ADC enable mask retval: " << retval;