diff --git a/slsReceiverSoftware/CMakeLists.txt b/slsReceiverSoftware/CMakeLists.txt index 49b0b1da1..983aed82a 100755 --- a/slsReceiverSoftware/CMakeLists.txt +++ b/slsReceiverSoftware/CMakeLists.txt @@ -1,6 +1,6 @@ set(SOURCES - src/slsReceiverImplementation.cpp - src/slsReceiverTCPIPInterface.cpp + src/Implementation.cpp + src/ClientInterface.cpp src/Receiver.cpp src/File.cpp src/BinaryFile.cpp diff --git a/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h b/slsReceiverSoftware/include/ClientInterface.h similarity index 50% rename from slsReceiverSoftware/include/slsReceiverTCPIPInterface.h rename to slsReceiverSoftware/include/ClientInterface.h index c28c524b9..39ace4847 100755 --- a/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h +++ b/slsReceiverSoftware/include/ClientInterface.h @@ -1,408 +1,148 @@ #pragma once -/********************************************/ /** - * @file - *slsReceiverTCPIPInterface.h - * @short interface between - *receiver and client - ***********************************************/ - #include "receiver_defs.h" #include "sls_detector_defs.h" - +#include "Implementation.h" +#include "ServerSocket.h" class MySocketTCP; class ServerInterface; -#include "ServerSocket.h" -#include "slsReceiverImplementation.h" -/** - *@short interface between receiver and client - */ -class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { + +class ClientInterface : private virtual slsDetectorDefs { private: enum numberMode { DEC, HEX }; public: - /** Destructor */ - virtual ~slsReceiverTCPIPInterface(); - - /** - * Constructor - * reads config file, creates socket, assigns function table - * throws an exception in case of failure to construct - * @param pn port number (defaults to default port number) - */ - - slsReceiverTCPIPInterface(int pn = -1); - - /** - * Starts listening on the TCP port for client comminication - */ - void start(); - - /** stop listening on the TCP & UDP port for client comminication */ - void stop(); - - /** gets version */ + virtual ~ClientInterface(); + ClientInterface(int portNumber = -1); int64_t getReceiverVersion(); //***callback functions*** - /** - * Call back for start acquisition - * callback arguments are - * filepath - * filename - * fileindex - * datasize - * - * return value is insignificant at the moment - * we write depending on file write enable - * users get data to write depending on call backs registered - */ + /** params: filepath, filename, fileindex, datasize */ void registerCallBackStartAcquisition(int (*func)(std::string, std::string, uint64_t, uint32_t, void *), void *arg); - /** - * Call back for acquisition finished - * callback argument is - * total frames caught - */ + /** params: total frames caught */ void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *), void *arg); - /** - * Call back for raw data - * args to raw data ready callback are - * sls_receiver_header frame metadata - * dataPointer is the pointer to the data - * dataSize in bytes is the size of the data in bytes. - */ + /** params: sls_receiver_header frame metadata, dataPointer, dataSize */ void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t, void *), void *arg); - /** - * Call back for raw data (modified) - * args to raw data ready callback are - * sls_receiver_header frame metadata - * 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). - */ + /** params: sls_receiver_header frame metadata, dataPointer, modified size */ void registerCallBackRawDataModifyReady(void (*func)(char *, char *, uint32_t &, void *), void *arg); private: - /** - * Static function - Thread started which is a TCP server - * Called by start() - * @param this_pointer pointer to this object - */ + void startTCPSocket(); + void stopTCPSocket(); static void *startTCPServerThread(void *this_pointer); - - /** - * Thread started which is a TCP server - * Called by start() - */ void startTCPServer(); - /** assigns functions to the fnum enum */ int function_table(); - - /** Decodes Function */ int decode_function(sls::ServerInterface2 &socket); - - /** function not implemented for specific detector */ void functionNotImplemented(); - - /** mode not implemented for specific detector */ void modeNotImplemented(const std::string& modename, int mode); - - /** validate and set error */ template void validate(T arg, T retval, std::string modename, numberMode hex); - /** Execute command */ int exec_command(sls::ServerInterface2 &socket); - - /** Exit Receiver Server */ int exit_server(sls::ServerInterface2 &socket); - - /** Locks Receiver */ int lock_receiver(sls::ServerInterface2 &socket); - - /** Get Last Client IP*/ int get_last_client_ip(sls::ServerInterface2 &socket); - - /** Set port */ int set_port(sls::ServerInterface2 &socket); - - /** Updates Client if different clients connect */ int update_client(sls::ServerInterface2 &socket); - - /** Sends the updated parameters to client */ int send_update(sls::ServerInterface2 &socket); - - /** get version */ int get_version(sls::ServerInterface2 &socket); - - /** Set detector type */ int set_detector_type(sls::ServerInterface2 &socket); - - /** set detector hostname */ int set_detector_hostname(sls::ServerInterface2 &socket); - - /** set roi */ int set_roi(sls::ServerInterface2 &socket); - - /** set num frames */ int set_num_frames(sls::ServerInterface2 &socket); - - /** set num analog samples */ int set_num_analog_samples(sls::ServerInterface2 &socket); - - /** set num digital samples */ int set_num_digital_samples(sls::ServerInterface2 &socket); - - /** set exptime */ int set_exptime(sls::ServerInterface2 &socket); - - /** set period */ int set_period(sls::ServerInterface2 &socket); - - /** set subexptime */ int set_subexptime(sls::ServerInterface2 &socket); - - /** set subdeadtime */ int set_subdeadtime(sls::ServerInterface2 &socket); - - /** set dynamic range */ int set_dynamic_range(sls::ServerInterface2 &socket); - - /** Sets the receiver streaming frequency */ int set_streaming_frequency(sls::ServerInterface2 &socket); - - /** Gets receiver status */ int get_status(sls::ServerInterface2 &socket); - - /** Start Receiver - starts listening to udp packets from detector */ int start_receiver(sls::ServerInterface2 &socket); - - /** Stop Receiver - stops listening to udp packets from detector*/ int stop_receiver(sls::ServerInterface2 &socket); - - /** Set File path */ int set_file_dir(sls::ServerInterface2 &socket); - - /** Set File name prefix */ int set_file_name(sls::ServerInterface2 &socket); - - /** Set File index */ int set_file_index(sls::ServerInterface2 &socket); - - /** Gets current frame index */ int get_frame_index(sls::ServerInterface2 &socket); - - /** Gets Total Frames Caught */ int get_frames_caught(sls::ServerInterface2 &socket); - - /** Enable File Write*/ int enable_file_write(sls::ServerInterface2 &socket); - - /** Enable Master File Write */ int enable_master_file_write(sls::ServerInterface2 &socket); - - /** enable compression */ int enable_compression(sls::ServerInterface2 &socket); - - /** enable overwrite */ int enable_overwrite(sls::ServerInterface2 &socket); - - /** enable 10Gbe */ int enable_tengiga(sls::ServerInterface2 &socket); - - /** set fifo depth */ int set_fifo_depth(sls::ServerInterface2 &socket); - - /** activate/ deactivate */ int set_activate(sls::ServerInterface2 &socket); - - /* Set the data stream enable */ int set_data_stream_enable(sls::ServerInterface2 &socket); - - /** Sets the steadming timer when frequency is set to 0 */ int set_streaming_timer(sls::ServerInterface2 &socket); - - /** enable flipped data */ int set_flipped_data(sls::ServerInterface2 &socket); - - /** set file format */ int set_file_format(sls::ServerInterface2 &socket); - - /** set position id */ int set_detector_posid(sls::ServerInterface2 &socket); - - /** set multi detector size */ int set_multi_detector_size(sls::ServerInterface2 &socket); - - /** set streaming port */ int set_streaming_port(sls::ServerInterface2 &socket); - - /** set streaming source ip */ int set_streaming_source_ip(sls::ServerInterface2 &socket); - - /** set silent mode */ int set_silent_mode(sls::ServerInterface2 &socket); - - /** enable gap pixels */ int enable_gap_pixels(sls::ServerInterface2 &socket); - - /** restream stop packet */ int restream_stop(sls::ServerInterface2 &socket); - - /** set additional json header */ int set_additional_json_header(sls::ServerInterface2 &socket); - - /** get additional json header */ int get_additional_json_header(sls::ServerInterface2 &socket); - - /** set udp socket buffer size */ int set_udp_socket_buffer_size(sls::ServerInterface2 &socket); - - /** get real udp socket buffer size */ int get_real_udp_socket_buffer_size(sls::ServerInterface2 &socket); - - /** set frames per file */ int set_frames_per_file(sls::ServerInterface2 &socket); - - /** check version compatibility */ int check_version_compatibility(sls::ServerInterface2 &socket); - - /** set frame discard policy */ int set_discard_policy(sls::ServerInterface2 &socket); - - /** set partial frame padding enable*/ int set_padding_enable(sls::ServerInterface2 &socket); - - /** set deactivated receiver padding enable */ int set_deactivated_padding_enable(sls::ServerInterface2 &socket); - - /** set readout mode */ int set_readout_mode(sls::ServerInterface2 &socket); - - /** set adc mask */ int set_adc_mask(sls::ServerInterface2 &socket); - - /** set receiver dbit list */ int set_dbit_list(sls::ServerInterface2 &socket); - - /** get receiver dbit list */ int get_dbit_list(sls::ServerInterface2 &socket); - - /** set dbit offset */ int set_dbit_offset(sls::ServerInterface2 &socket); - - /** quad type */ int set_quad_type(sls::ServerInterface2 &socket); - - /** read n lines */ int set_read_n_lines(sls::ServerInterface2 &socket); - - /** set udp ip */ int set_udp_ip(sls::ServerInterface2 &socket); - - /** set udp ip2 */ int set_udp_ip2(sls::ServerInterface2 &socket); - - /** set udp port */ int set_udp_port(sls::ServerInterface2 &socket); - - /** set udp port2 */ int set_udp_port2(sls::ServerInterface2 &socket); - - /** set number of udp interfaces */ int set_num_interfaces(sls::ServerInterface2 &socket); - - /** detector type */ detectorType myDetectorType; - - /** slsReceiverBase object */ - std::unique_ptr receiver{nullptr}; - - /** Function List */ - int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])( + std::unique_ptr receiver{nullptr}; + int (ClientInterface::*flist[NUM_REC_FUNCTIONS])( sls::ServerInterface2 &socket); - - /** success/failure */ int ret{OK}; - - /** function index */ int fnum{-1}; - /** Lock Status if server locked to a client */ int lockStatus{0}; - /** kill tcp server thread */ int killTCPServerThread{0}; - - /** thread for TCP server */ pthread_t TCPServer_thread; - - /** tcp thread created flag*/ bool tcpThreadCreated{false}; - /** port number */ int portNumber; //***callback parameters*** - /** - * Call back for start acquisition - * callback arguments are - * filepath - * filename - * fileindex - * datasize - * - * return value is insignificant at the moment - * we write depending on file write enable - * users get data to write depending on call backs registered - */ + int (*startAcquisitionCallBack)(std::string, std::string, uint64_t, uint32_t, void *) = nullptr; void *pStartAcquisition{nullptr}; - - /** - * Call back for acquisition finished - * callback argument is - * total frames caught - */ void (*acquisitionFinishedCallBack)(uint64_t, void *) = nullptr; void *pAcquisitionFinished{nullptr}; - - /** - * Call back for raw data - * args to raw data ready callback are - * sls_receiver_header frame metadata - * dataPointer is the pointer to the data - * dataSize in bytes is the size of the data in bytes. - */ void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *) = nullptr; - - /** - * Call back for raw data (modified) - * args to raw data ready callback are - * sls_receiver_header frame metadata - * 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). - */ void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &, void *) = nullptr; - void *pRawDataReady{nullptr}; protected: @@ -412,7 +152,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { void VerifyLock(); void VerifyIdle(sls::ServerInterface2 &socket); - slsReceiverImplementation *impl() { + Implementation *impl() { if (receiver != nullptr) { return receiver.get(); } else { diff --git a/slsReceiverSoftware/include/Implementation.h b/slsReceiverSoftware/include/Implementation.h new file mode 100755 index 000000000..8a485ebbc --- /dev/null +++ b/slsReceiverSoftware/include/Implementation.h @@ -0,0 +1,310 @@ +#pragma once +#include "container_utils.h" +#include "logger.h" +#include "receiver_defs.h" +#include "network_utils.h" +class GeneralData; +class Listener; +class DataProcessor; +class DataStreamer; +class Fifo; +class slsDetectorDefs; + +#include +#include +#include +#include + +class Implementation : private virtual slsDetectorDefs { + public: + //*** cosntructor & destructor *** + /** + * Constructor + */ + Implementation(); + + /** + * Destructor + */ + virtual ~Implementation(); + + /************************************************************************* + * Getters *************************************************************** + * They access local cache of configuration or detector parameters ******* + *************************************************************************/ + + //**initial parameters*** + int *getMultiDetectorSize() const; + int getDetectorPositionId() const; + std::string getDetectorHostname() const; + int getFlippedDataX() const; + bool getGapPixelsEnable() const; + bool getQuad() const; + int getReadNLines() const; + readoutMode getReadoutMode() const; + + //***file parameters*** + fileFormat getFileFormat() const; + std::string getFileName() const; + std::string getFilePath() const; + uint64_t getFileIndex() const; + uint32_t getFramesPerFile() const; + frameDiscardPolicy getFrameDiscardPolicy() const; + bool getFramePaddingEnable() const; + bool getFileWriteEnable() const; + bool getMasterFileWriteEnable() const; + bool getOverwriteEnable() const; + + //***acquisition count parameters*** + uint64_t getFramesCaught() const; + uint64_t getAcquisitionIndex() const; + + //***connection parameters*** + uint32_t getUDPPortNumber() const; + uint32_t getUDPPortNumber2() const; + std::string getEthernetInterface() const; + std::string getEthernetInterface2() const; + int getNumberofUDPInterfaces() const; + + //***acquisition parameters*** + ROI getROI() const; + uint32_t getADCEnableMask() const; + uint32_t getStreamingFrequency() const; + uint32_t getStreamingTimer() const; + bool getDataStreamEnable() const; + uint64_t getAcquisitionPeriod() const; + uint64_t getAcquisitionTime() const; + uint64_t getSubExpTime() const; + uint64_t getSubPeriod() const; + uint64_t getNumberOfFrames() const; + uint32_t getNumberofAnalogSamples() const; + uint32_t getNumberofDigitalSamples() const; + uint32_t getDynamicRange() const; + bool getTenGigaEnable() const; + uint32_t getFifoDepth() const; + + //***receiver status*** + runStatus getStatus() const; + bool getSilentMode() const; + std::vector getDbitList() const; + int getDbitOffset() const; + bool getActivate() const; + bool getDeactivatedPadding() const; + uint32_t getStreamingPort() const; + sls::IpAddr getStreamingSourceIP() const; + std::string getAdditionalJsonHeader() const; + int64_t getUDPSocketBufferSize() const; + int64_t getActualUDPSocketBufferSize() const; + + /************************************************************************* + * Setters *************************************************************** + * They modify the local cache of configuration or detector parameters *** + *************************************************************************/ + + //**initial parameters*** + void setDetectorHostname(const std::string& c); + void setMultiDetectorSize(const int *size); + void setFlippedDataX(int enable = -1); + /* [Eiger] */ + int setGapPixelsEnable(const bool b); + /* [Eiger] */ + int setQuad(const bool b); + /* [Eiger] */ + void setReadNLines(const int value); + /* [Ctb] */ + int setReadoutMode(const readoutMode f); + + //***file parameters*** + void setFileFormat(slsDetectorDefs::fileFormat f); + void setFileName(const std::string& c); + /* check for existence */ + void setFilePath(const std::string& c); + void setFileIndex(const uint64_t i); + /* 0 means infinite */ + void setFramesPerFile(const uint32_t i); + void setFrameDiscardPolicy(const frameDiscardPolicy i); + void setFramePaddingEnable(const bool i); + void setFileWriteEnable(const bool b); + void setMasterFileWriteEnable(const bool b); + void setOverwriteEnable(const bool b); + + //***connection parameters*** + void setUDPPortNumber(const uint32_t i); + /* [Eiger][Jungfrau] */ + void setUDPPortNumber2(const uint32_t i); + void setEthernetInterface(const std::string &c); + /* [Jungfrau] */ + void setEthernetInterface2(const std::string &c); + /* [Jungfrau] */ + int setNumberofUDPInterfaces(const int n); + int setUDPSocketBufferSize(const int64_t s); + + //***acquisition parameters*** + /* [Gotthard] */ + int setROI(ROI arg); + /* [Ctb][Moench] */ + int setADCEnableMask(const uint32_t mask); + /* 0 for timer */ + int setStreamingFrequency(const uint32_t freq); + void setStreamingTimer(const uint32_t time_in_ms); + int setDataStreamEnable(const bool enable); + void setStreamingPort(const uint32_t i); + void setStreamingSourceIP(const sls::IpAddr ip); + void setAdditionalJsonHeader(const std::string& c); + void setAcquisitionPeriod(const uint64_t i); + void setAcquisitionTime(const uint64_t i); + void setSubExpTime(const uint64_t i); + void setSubPeriod(const uint64_t i); + void setNumberOfFrames(const uint64_t i); + int setNumberofAnalogSamples(const uint32_t i); + int setNumberofDigitalSamples(const uint32_t i); + int setDynamicRange(const uint32_t i); + /* [Eiger][Ctb] */ + int setTenGigaEnable(const bool b); + int setFifoDepth(const uint32_t i); + + //***receiver parameters*** + /** [Eiger] + * Activate / Deactivate Receiver + * If deactivated, receiver will create dummy data if deactivated padding is + * enabled (as it will receive nothing from detector) + * @param enable enable + * @return false for disabled, true for enabled + */ + bool setActivate(const bool enable); + /* [Eiger] */ + bool setDeactivatedPadding(const bool enable); + void setSilentMode(const bool i); + /* [Ctb] */ + void setDbitList(const std::vector v); + /* [Ctb] */ + void setDbitOffset(const int s); + + /************************************************************************* + * Behavioral functions*************************************************** + * They may modify the status of the receiver **************************** + *************************************************************************/ + + //***initial functions*** + /** + * Set receiver type (and corresponding detector variables in derived + * STANDARD class) It is the first function called by the client when + * connecting to receiver + * @param d detector type + * @return OK or FAIL + */ + int setDetectorType(const detectorType d); + void setDetectorPositionId(const int id); + + //***acquisition functions*** + int startReceiver(std::string& err); + void stopReceiver(); + void startReadout(); + void shutDownUDPSockets(); + void closeFiles(); + int restreamStop(); + + //***callback functions*** + void registerCallBackStartAcquisition(int (*func)(std::string, std::string, uint64_t, + uint32_t, void *), + void *arg); + void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *), + void *arg); + void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t, + void *), + void *arg); + void registerCallBackRawDataModifyReady(void (*func)(char *, char *, + uint32_t &, void *), + void *arg); + + private: + void DeleteMembers(); + void InitializeMembers(); + void SetLocalNetworkParameters(); + void SetThreadPriorities(); + int SetupFifoStructure(); + void ResetParametersforNewAcquisition(); + int CreateUDPSockets(); + int SetupWriter(); + void StartRunning(); + + /************************************************************************* + * Class Members ********************************************************* + *************************************************************************/ + //**detector parameters*** + detectorType myDetectorType; + int numDet[MAX_DIMENSIONS]; + int detID; + std::string detHostname; + uint64_t acquisitionPeriod; + uint64_t acquisitionTime; + uint64_t subExpTime; + uint64_t subPeriod; + uint64_t numberOfFrames; + uint64_t numberOfAnalogSamples; + uint64_t numberOfDigitalSamples; + uint32_t dynamicRange; + bool tengigaEnable; + uint32_t fifoDepth; + int flippedDataX; + bool gapPixelsEnable; + bool quadEnable; + int numLinesReadout; + readoutMode readoutType; + + //*** receiver parameters *** + int numThreads; + const static int MAX_NUMBER_OF_LISTENING_THREADS = 2; + std::atomic status; + bool activated; + bool deactivatedPaddingEnable; + frameDiscardPolicy frameDiscardMode; + bool framePadding; + bool silentMode; + std::vector ctbDbitList; + int ctbDbitOffset; + int ctbAnalogDataBytes; + + //***connection parameters*** + int numUDPInterfaces; + std::vector eth; + uint32_t udpPortNum[MAX_NUMBER_OF_LISTENING_THREADS]; + int64_t udpSocketBufferSize; + int64_t actualUDPSocketBufferSize; + + //***file parameters*** + fileFormat fileFormatType; + std::string fileName; + std::string filePath; + uint64_t fileIndex; + uint32_t framesPerFile; + bool fileWriteEnable; + bool masterFileWriteEnable; + bool overwriteEnable; + + //***acquisition parameters*** + ROI roi; + uint32_t adcEnableMask; + uint32_t streamingFrequency; + uint32_t streamingTimerInMs; + bool dataStreamEnable; + uint32_t streamingPort; + sls::IpAddr streamingSrcIP; + std::string additionalJsonHeader; + + //** class objects *** + GeneralData *generalData; + std::vector> listener; + std::vector> dataProcessor; + std::vector> dataStreamer; + std::vector> fifo; + + //***callback parameters*** + int (*startAcquisitionCallBack)(std::string, std::string, uint64_t, uint32_t, void *); + void *pStartAcquisition; + void (*acquisitionFinishedCallBack)(uint64_t, void *); + void *pAcquisitionFinished; + void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *); + void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &, void *); + void *pRawDataReady; +}; diff --git a/slsReceiverSoftware/include/Receiver.h b/slsReceiverSoftware/include/Receiver.h index 1e8c5a9b5..dc0bc5e35 100755 --- a/slsReceiverSoftware/include/Receiver.h +++ b/slsReceiverSoftware/include/Receiver.h @@ -1,5 +1,5 @@ #pragma once -#include "slsReceiverTCPIPInterface.h" +#include "ClientInterface.h" #include "sls_detector_defs.h" #include @@ -76,5 +76,5 @@ class Receiver : private virtual slsDetectorDefs { private: - std::unique_ptr tcpipInterface; + std::unique_ptr tcpipInterface; }; diff --git a/slsReceiverSoftware/include/slsReceiverImplementation.h b/slsReceiverSoftware/include/slsReceiverImplementation.h deleted file mode 100755 index 23ac7070a..000000000 --- a/slsReceiverSoftware/include/slsReceiverImplementation.h +++ /dev/null @@ -1,1021 +0,0 @@ -#pragma once -/********************************************/ /** - * @file - *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. - */ -// #include "sls_detector_defs.h" -#include "container_utils.h" -#include "logger.h" -#include "receiver_defs.h" -#include "network_utils.h" -class GeneralData; -class Listener; -class DataProcessor; -class DataStreamer; -class Fifo; -class slsDetectorDefs; - -#include -#include -#include -#include - -class slsReceiverImplementation : private virtual slsDetectorDefs { - public: - //*** cosntructor & destructor *** - /** - * Constructor - */ - slsReceiverImplementation(); - - /** - * Destructor - */ - virtual ~slsReceiverImplementation(); - - /************************************************************************* - * Getters *************************************************************** - * They access local cache of configuration or detector parameters ******* - *************************************************************************/ - - //**initial parameters*** - /* - * Get multi detector size - * @return pointer to array of multi detector size in every dimension - */ - int *getMultiDetectorSize() const; - - /* - * Get detector position id - * @return detector position id - */ - int getDetectorPositionId() const; - - /* - * Get detector hostname - * @return hostname - */ - std::string getDetectorHostname() const; - - /* - * Get flipped data across x axis - * @return if data is flipped across x axis - */ - int getFlippedDataX() const; - - /** - * Get Gap Pixels Enable (eiger specific) - * @return true if gap pixels enabled, else false - */ - bool getGapPixelsEnable() const; - - /** - * Get Quad type Enable (eiger and hardware specific) - * @return true if quad enabled, else false - */ - bool getQuad() const; - - /** - * Get number of lines readout (eiger) - * @returns number of lines readout - */ - int getReadNLines() const; - - /** - * Get readout mode (chiptestboard) - * @return readout mode - */ - readoutMode getReadoutMode() const; - - //***file parameters*** - /** - * Get File Format - * @return file format - */ - fileFormat getFileFormat() const; - /** - * Get File Name Prefix (without frame index, file index and extension - * (_d0_f000000000000_8.raw)) - * @return file name prefix - */ - std::string getFileName() const; - - /** - * Get File Path - * @return file path - */ - std::string getFilePath() const; - - /** - * Get File Index - * @return file index of acquisition - */ - uint64_t getFileIndex() const; - - /** - * Get Frames per File (0 means infinite) - * @return Frames per File - */ - uint32_t getFramesPerFile() const; - - /** - * Get Frame Discard Policy - * @return Frame Discard Policy - */ - frameDiscardPolicy getFrameDiscardPolicy() const; - - /** - * Get Partial Frame Padding Enable - * @return Partial Frame Padding Enable - */ - bool getFramePaddingEnable() const; - - /** - * Get File Write Enable - * @return true if file write enabled, else false - */ - bool getFileWriteEnable() const; - - /** - * Get Master File Write Enable - * @return true if Master file write enabled, else false - */ - bool getMasterFileWriteEnable() const; - - /** - * Get File Over Write Enable - * @return true if file over write enabled, else false - */ - bool getOverwriteEnable() const; - - //***acquisition count parameters*** - /** - * Get Frames Caught - * @return number of frames caught (0 if none, else min of all) - */ - uint64_t getFramesCaught() const; - - /** - * Get Current Frame Index - * @return current frame index (0 if none, else min of all) - */ - uint64_t getAcquisitionIndex() const; - - //***connection parameters*** - /** - * Get UDP Port Number - * @return udp port number - */ - uint32_t getUDPPortNumber() const; - - /** - * Get Second UDP Port Number (eiger/jungfrau specific) - * @return second udp port number - */ - uint32_t getUDPPortNumber2() const; - - /** - * Get Ehernet Interface - * @return ethernet interface. eg. eth0 or "" if listening to all - */ - std::string getEthernetInterface() const; - - /** - * Get Ehernet Interface 2 (jungfrau specific) - * @return ethernet interface 2. eg. eth0 or "" if listening to all - */ - std::string getEthernetInterface2() const; - - /** - * Get number of UDP Interfaces (jungfrau specific) - * @return number of udp interfaces. Options (1-2) - */ - int getNumberofUDPInterfaces() const; - - //***acquisition parameters*** - /** - * Get ROI - * @return roi - */ - ROI getROI() const; - - /** - * Get ADC Enable Mask - * @return ADC Enable Mask - */ - uint32_t getADCEnableMask() const; - - /** - * Get the streaming frequency - * @return 0 for timer, n for nth frame frequency - */ - uint32_t getStreamingFrequency() const; - - /** - * Gets the timer between frames streamed when frequency is set to 0 - * @return timer between frames streamed - */ - uint32_t getStreamingTimer() const; - - /** - * Get the data stream enable - * @return data stream enable - */ - bool getDataStreamEnable() const; - - /** - * Get Acquisition Period - * @return acquisition period - */ - uint64_t getAcquisitionPeriod() const; - - /** - * Get Acquisition Time - * @return acquisition time - */ - uint64_t getAcquisitionTime() const; - - /** - * Get Sub Exposure Time - * @return Sub Exposure Time - */ - uint64_t getSubExpTime() const; - - /** - * Get Sub Period - * @return Sub Period - */ - uint64_t getSubPeriod() const; - - /* - * 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) - * @return number of frames expected - */ - uint64_t getNumberOfFrames() const; - - /* - * Get Number of Analog Samples expected by receiver from detector (for chip - * test board and moench only) - * @return number of Analog samples expected - */ - uint32_t getNumberofAnalogSamples() const; - - /* - * Get Number of Digital Samples expected by receiver from detector (for - * chip test board and moench only) - * @return number of Digital samples expected - */ - uint32_t getNumberofDigitalSamples() const; - - /** - * Get Dynamic Range or Number of Bits Per Pixel - * @return dynamic range that is 4, 8, 16 or 32 - */ - uint32_t getDynamicRange() const; - - /** - * Get Ten Giga Enable - * @return true if 10Giga enabled, else false (1G enabled) - */ - bool getTenGigaEnable() const; - - /** - * Get Fifo Depth - * @return fifo depth - */ - uint32_t getFifoDepth() const; - - //***receiver status*** - /** - * Get Listening Status of Receiver - * @return can be idle, listening or error depending on if the receiver is - * listening or not - */ - runStatus getStatus() const; - - /** - * Get Silent Mode - * @return silent mode - */ - bool getSilentMode() const; - - /** - * Get CTB digital bits enable list - * @returns digital bits enable list - */ - std::vector getDbitList() const; - - /** - * Get CTB digital bits offset - * @returns digital bits offset - */ - int getDbitOffset() const; - - /** - * Get activate - * If deactivated, receiver will create dummy data if deactivated padding is - * enabled (as it will receive nothing from detector) - * @return false for deactivated, true for activated - */ - bool getActivate() const; - - /** - * Get deactivated padding enable - * If enabled, receiver will create dummy packets (0xFF), else it will - * create nothing (as it will receive nothing from detector) - * @return 0 for disabled, 1 for enabled - */ - bool getDeactivatedPadding() const; - - /** - * Get Streaming Port - * @return streaming port - */ - uint32_t getStreamingPort() const; - - /** - * Get streaming source ip - * @return streaming source ip - */ - sls::IpAddr getStreamingSourceIP() const; - - /** - * Get additional json header - * @return additional json header - */ - std::string getAdditionalJsonHeader() const; - - /** (not saved in client shared memory) - * Get UDP Socket Buffer Size - * @return UDP Socket Buffer Size - */ - int64_t getUDPSocketBufferSize() const; - - /** (not saved in client shared memory) - * Get actual UDP Socket Buffer Size - * @return actual UDP Socket Buffer Size - */ - int64_t getActualUDPSocketBufferSize() const; - - /************************************************************************* - * Setters *************************************************************** - * They modify the local cache of configuration or detector parameters *** - *************************************************************************/ - - //**initial parameters*** - /** - * Sets detector hostname - * @param c detector hostname - */ - void setDetectorHostname(const std::string& c); - - /* - * Set multi detector size - * @param pointer to array of multi detector size in every dimension - */ - void setMultiDetectorSize(const int *size); - - /* - * Get flipped data across x axis - * @return if data is flipped across x axis - */ - void setFlippedDataX(int enable = -1); - - /** - * Set Gap Pixels Enable (eiger specific) - * @param b true for gap pixels enable, else false - * @return OK or FAIL - */ - int setGapPixelsEnable(const bool b); - - /** - * Set Quad type Enable (eiger and hardware specific) - * @param true if quad enabled, else false - * @return OK or FAIL - */ - int setQuad(const bool b); - - /** - * Set number of lines readout (eiger) - * @param value number of lines readout - */ - void setReadNLines(const int value); - - /** - * Set readout mode (chiptestboard) - * @param f readout mode - * @return OK or FAIL - */ - int setReadoutMode(const readoutMode f); - - //***file parameters*** - /** - * Set File Format - * @param f fileformat binary or hdf5 - */ - void setFileFormat(slsDetectorDefs::fileFormat f); - - /** - * Set File Name Prefix (without frame index, file index and extension - * (_d0_f000000000000_8.raw)) Does not check for file existence since it is - * created only at startReceiver - * @param c file name - */ - void setFileName(const std::string& c); - - /** - * Set File Path - * Checks for file directory existence before setting file path, - * If it exists, it sets it - * @param c file path - */ - void setFilePath(const std::string& c); - - /** - * Set File Index of acquisition - * @param i file index of acquisition - */ - void setFileIndex(const uint64_t i); - - /** - * Set Frames per File (0 means infinite) - * @param i Frames per File - */ - void setFramesPerFile(const uint32_t i); - - /** - * Set Frame Discard Policy - * @param i Frame Discard Policy - */ - void setFrameDiscardPolicy(const frameDiscardPolicy i); - - /** - * Set Partial Frame Padding Enable - * @param i Partial Frame Padding Enable - */ - void setFramePaddingEnable(const bool i); - - /** - * Set File Write Enable - * @param b true for file write enable, else false - */ - void setFileWriteEnable(const bool b); - - /** - * Set Master File Write Enable - * @param b true for Master file write enable, else false - */ - void setMasterFileWriteEnable(const bool b); - - /** - * Set File Overwrite Enable - * @param b true for file overwrite enable, else false - */ - void setOverwriteEnable(const bool b); - - //***connection parameters*** - /** - * Set UDP Port Number - * @param i udp port number - */ - void setUDPPortNumber(const uint32_t i); - - /** - * Set Second UDP Port Number (eiger/jungfrau specific) - * @return second udp port number - */ - void setUDPPortNumber2(const uint32_t i); - - /** - * Set Ethernet Interface to listen to - * @param c ethernet inerface eg. eth0 - */ - void setEthernetInterface(const std::string &c); - - /** - * Set second Ethernet Interface to listen to (jungfrau specific) - * @param c second ethernet inerface eg. eth0 - */ - void setEthernetInterface2(const std::string &c); - - /** - * Set number of UDP Interfaces (jungfrau specific) - * @param n number of udp interfaces. Options (1-2) - * @return OK or FAIL for fifo structure creation - */ - int setNumberofUDPInterfaces(const int n); - - /** (not saved in client shared memory) - * Set UDP Socket Buffer Size - * @param s UDP Socket Buffer Size - * @return OK or FAIL if dummy socket could be created - */ - int setUDPSocketBufferSize(const int64_t s); - - //***acquisition parameters*** - /** - * Set ROI - * @param arg ROI - * @return OK or FAIL - */ - int setROI(ROI arg); - - /** - * Set ADC Enable Mask - * @param mask ADC Enable Mask - * @return OK or FAIL - */ - int setADCEnableMask(const uint32_t mask); - - /** - * Set the streaming frequency - * @param freq 0 for timer, n for nth frame frequency - * @return OK or FAIL - */ - int setStreamingFrequency(const uint32_t freq); - - /** - * Sets the timer between frames streamed when frequency is set to 0 - * @param time_in_ms timer between frames streamed - */ - void setStreamingTimer(const uint32_t time_in_ms); - /** - * Set the data stream enable - * @param enable data stream enable - * @return OK or FAIL - */ - int setDataStreamEnable(const bool enable); - - /** - * Set streaming port - * @param i streaming port - */ - void setStreamingPort(const uint32_t i); - - /** - * Set streaming source ip - * @param c streaming source ip - */ - void setStreamingSourceIP(const sls::IpAddr ip); - - /** - * Set additional json header - */ - void setAdditionalJsonHeader(const std::string& c); - - /** - * Set Acquisition Period - * @param i acquisition period - */ - void setAcquisitionPeriod(const uint64_t i); - - /** - * Set Acquisition Time - * @param i acquisition time - */ - void setAcquisitionTime(const uint64_t i); - - /** - * Set Sub Exposure Time - * @param i Sub Exposure Time - * @return OK or FAIL - */ - void setSubExpTime(const uint64_t i); - - /** - * Set Sub Period - * @param i Period - * @return OK or FAIL - */ - void setSubPeriod(const uint64_t i); - - /** - * 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 - * @param i number of frames expected - */ - void setNumberOfFrames(const uint64_t i); - - /** - * Set Number of Analog Samples expected by receiver from detector - * @param i number of Analog Samples expected - * @return OK or FAIL - */ - int setNumberofAnalogSamples(const uint32_t i); - - /** - * Set Number of Digital Samples expected by receiver from detector - * @param i number of Digital Samples expected - * @return OK or FAIL - */ - int setNumberofDigitalSamples(const uint32_t i); - - /** - * Set Dynamic Range or Number of Bits Per Pixel - * @param i dynamic range that is 4, 8, 16 or 32 - * @return OK or FAIL - */ - int setDynamicRange(const uint32_t i); - - /** - * Set Ten Giga Enable - * @param b true if 10GbE enabled, else false (1G enabled) - * @return OK or FAIL - */ - int setTenGigaEnable(const bool b); - - /** - * Set Fifo Depth - * @param i fifo depth value - * @return OK or FAIL - */ - int setFifoDepth(const uint32_t i); - - //***receiver parameters*** - /** - * Activate / Deactivate Receiver - * If deactivated, receiver will create dummy data if deactivated padding is - * enabled (as it will receive nothing from detector) - * @param enable enable - * @return false for disabled, true for enabled - */ - bool setActivate(const bool enable); - - /** - * Set deactivated padding enable - * If enabled, receiver will create dummy packets (0xFF), else it will - * create nothing (as it will receive nothing from detector) - * @param enable enable - * @return false for disabled, true for enabled - */ - bool setDeactivatedPadding(const bool enable); - - /** - * Set Silent Mode - * @param i silent mode. true sets, false unsets - */ - void setSilentMode(const bool i); - - /** - * Set CTB digital bits enable list - * @param v digital bits enable list - */ - void setDbitList(const std::vector v); - - /** - * Set CTB digital bits offset - * @param s digital bits offset - */ - void setDbitOffset(const int s); - - /************************************************************************* - * Behavioral functions*************************************************** - * They may modify the status of the receiver **************************** - *************************************************************************/ - - //***initial functions*** - /** - * Set receiver type (and corresponding detector variables in derived - * STANDARD class) It is the first function called by the client when - * connecting to receiver - * @param d detector type - * @return OK or FAIL - */ - int setDetectorType(const detectorType d); - - /** - * Set detector position id and construct filewriter - * @param id position id - */ - void setDetectorPositionId(const int id); - - //***acquisition functions*** - - /** - * Start Listening for Packets by activating all configuration settings to - * receiver When this function returns, it has status RUNNING(upon SUCCESS) - * or IDLE (upon failure) - * @param c error message if FAIL - * @return OK or FAIL - */ - int startReceiver(std::string& err); - - /** - * Stop Listening for Packets - * Calls startReadout(), which stops listening and sets status to - * Transmitting When it has read every frame in buffer, the status changes - * to Run_Finished When this function returns, receiver has status IDLE Pre: - * status is running, semaphores have been instantiated, Post: udp sockets - * shut down, status is idle, semaphores destroyed - */ - void stopReceiver(); - - /** - * Stop Listening to Packets - * and sets status to Transmitting - * Next step would be to get all data and stop receiver completely and - * return with idle state Pre: status is running, udp sockets have been - * initialized, stop receiver initiated Post:udp sockets closed, status is - * transmitting - */ - void startReadout(); - - /** - * Shuts down and deletes UDP Sockets - * also called in case of illegal shutdown of receiver - */ - void shutDownUDPSockets(); - - /** - * Closes file / all files(data compression involves multiple files) - */ - void closeFiles(); - - /** - * Restream stop dummy packet from receiver - * @return OK or FAIL - */ - int restreamStop(); - - //***callback functions*** - /** - * Call back for start acquisition - * callback arguments are - * filepath - * filename - * fileindex - * datasize - * - * return value is insignificant at the moment - * we write depending on file write enable - * users get data to write depending on call backs registered - */ - void registerCallBackStartAcquisition(int (*func)(std::string, std::string, uint64_t, - uint32_t, void *), - void *arg); - - /** - * Call back for acquisition finished - * callback argument is - * total frames caught - */ - void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *), - void *arg); - - /** - * Call back for raw data - * args to raw data ready callback are - * sls_receiver_header frame metadata - * dataPointer is the pointer to the data - * dataSize in bytes is the size of the data in bytes. - */ - void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t, - void *), - void *arg); - - /** - * Call back for raw data (modified) - * args to raw data ready callback are - * sls_receiver_header frame metadata - * 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). - */ - void registerCallBackRawDataModifyReady(void (*func)(char *, char *, - uint32_t &, void *), - void *arg); - - private: - /** - * Delete and free member parameters - */ - void DeleteMembers(); - - /** - * Initialize member parameters - */ - void InitializeMembers(); - - /** - * Sets local network parameters, but requires permissions - */ - void SetLocalNetworkParameters(); - - /** - * Set Thread Priorities - */ - void SetThreadPriorities(); - - /** - * Set up the Fifo Structure for processing buffers - * between listening and dataprocessor threads - * @return OK or FAIL - */ - int SetupFifoStructure(); - - /** - * Reset parameters for new acquisition - */ - void ResetParametersforNewAcquisition(); - - /** - * Creates UDP Sockets - * @return OK or FAIL - */ - int CreateUDPSockets(); - - /** - * Creates the first file - * also does the startAcquisitionCallBack - * @return OK or FAIL - */ - int SetupWriter(); - - /** - * Start Running - * Set running mask and post semaphore of the threads - * to start the inner loop in execution thread - */ - void StartRunning(); - - /************************************************************************* - * Class Members ********************************************************* - *************************************************************************/ - //**detector parameters*** - /** detector type */ - detectorType myDetectorType; - /** Number of Detectors in each dimension direction */ - int numDet[MAX_DIMENSIONS]; - /*Detector Readout ID*/ - int detID; - /** detector hostname */ - std::string detHostname; - /** Acquisition Period */ - uint64_t acquisitionPeriod; - /** Acquisition Time */ - uint64_t acquisitionTime; - /** Sub Exposure Time */ - uint64_t subExpTime; - /** Sub Period */ - uint64_t subPeriod; - /** Frame Number */ - uint64_t numberOfFrames; - /** Analog Samples Number */ - uint64_t numberOfAnalogSamples; - /** Digital Samples Number */ - uint64_t numberOfDigitalSamples; - /** Dynamic Range */ - uint32_t dynamicRange; - /** Ten Giga Enable*/ - bool tengigaEnable; - /** Fifo Depth */ - uint32_t fifoDepth; - /** flipped data x across x axis (bottom eiger) */ - int flippedDataX; - /** gap pixels enable */ - bool gapPixelsEnable; - /** quad type enable */ - bool quadEnable; - /** num lines readout */ - int numLinesReadout; - /** readout mode*/ - readoutMode readoutType; - - //*** receiver parameters *** - /** Number of Threads */ - int numThreads; - /** Maximum Number of Listening Threads/ UDP Ports */ - const static int MAX_NUMBER_OF_LISTENING_THREADS = 2; - /** Receiver Status */ - std::atomic status; - /** Activated/Deactivated */ - bool activated; - /** Deactivated padding enable */ - bool deactivatedPaddingEnable; - /** frame discard policy */ - frameDiscardPolicy frameDiscardMode; - /** frame padding */ - bool framePadding; - /** silent mode */ - bool silentMode; - /** ctb digital bits enabled list (empty: all enabled) */ - std::vector ctbDbitList; - /** ctb digital bit offset in bytes */ - int ctbDbitOffset; - /* analog data bytes */ - int ctbAnalogDataBytes; - - //***connection parameters*** - /** Number of UDP Interfaces */ - int numUDPInterfaces; - /** Ethernet Interface */ - std::vector eth; - /** Server UDP Port Number*/ - uint32_t udpPortNum[MAX_NUMBER_OF_LISTENING_THREADS]; - /** udp socket buffer size */ - int64_t udpSocketBufferSize; - /** actual UDP Socket Buffer Size (halved due to kernel bookkeeping) */ - int64_t actualUDPSocketBufferSize; - - //***file parameters*** - /** File format */ - fileFormat fileFormatType; - /** File Name without frame index, file index and extension - * (_d0_f0_8.raw)*/ - std::string fileName; - /** File Path */ - std::string filePath; - /** File Index */ - uint64_t fileIndex; - /** Frames per file (0 means infinite) */ - uint32_t framesPerFile; - /** File Write enable */ - bool fileWriteEnable; - /** MasterFile Write enable */ - bool masterFileWriteEnable; - /** Overwrite enable */ - bool overwriteEnable; - - //***acquisition parameters*** - /* ROI */ - ROI roi; - /** ADC Enable Mask */ - uint32_t adcEnableMask; - /** streaming frequency */ - uint32_t streamingFrequency; - /** Streaming timer when frequency is 0 */ - uint32_t streamingTimerInMs; - /** Data Stream Enable from Receiver */ - bool dataStreamEnable; - /** streaming port */ - uint32_t streamingPort; - /** streaming port */ - sls::IpAddr streamingSrcIP; - /** additional json header */ - std::string additionalJsonHeader; - - //** class objects *** - /** General Data Properties */ - GeneralData *generalData; - /** Listener Objects that listen to UDP and push into fifo */ - std::vector> listener; - /** DataProcessor Objects that pull from fifo and process data */ - std::vector> dataProcessor; - /** DataStreamer Objects that stream data via ZMQ */ - std::vector> dataStreamer; - /** Fifo Structure to store addresses of memory writes */ - std::vector> fifo; - - //***callback parameters*** - /** - * Call back for start acquisition - * callback arguments are - * filepath - * filename - * fileindex - * datasize - * - * return value is insignificant at the moment - * we write depending on file write enable - * users get data to write depending on call backs registered - */ - int (*startAcquisitionCallBack)(std::string, std::string, uint64_t, uint32_t, void *); - void *pStartAcquisition; - /** - * Call back for acquisition finished - * callback argument is - * total frames caught - */ - void (*acquisitionFinishedCallBack)(uint64_t, void *); - void *pAcquisitionFinished; - /** - * Call back for raw data - * args to raw data ready callback are - * sls_receiver_header frame metadata - * dataPointer is the pointer to the data - * dataSize in bytes is the size of the data in bytes. - */ - void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *); - /** - * Call back for raw data (modified) - * args to raw data ready callback are - * sls_receiver_header frame metadata - * 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). - */ - void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &, void *); - - void *pRawDataReady; -}; diff --git a/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp b/slsReceiverSoftware/src/ClientInterface.cpp similarity index 75% rename from slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp rename to slsReceiverSoftware/src/ClientInterface.cpp index 80c84ebec..890f3d2b5 100755 --- a/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp +++ b/slsReceiverSoftware/src/ClientInterface.cpp @@ -1,14 +1,6 @@ -/********************************************** - * @file - *slsReceiverTCPIPInterface.cpp - * @short interface between - *receiver and client - ***********************************************/ - -#include "slsReceiverTCPIPInterface.h" +#include "ClientInterface.h" #include "FixedCapacityContainer.h" #include "ServerSocket.h" -#include "slsReceiverImplementation.h" #include "sls_detector_exceptions.h" #include "string_utils.h" #include "versionAPI.h" @@ -28,15 +20,15 @@ using sls::RuntimeError; using sls::SocketError; using Interface = sls::ServerInterface2; -slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { stop(); } +ClientInterface::~ClientInterface() { stopTCPSocket(); } -slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int pn) - : myDetectorType(GOTTHARD), portNumber(pn > 0 ? pn : DEFAULT_PORTNO + 2) { +ClientInterface::ClientInterface(int portNumber) + : myDetectorType(GOTTHARD), portNumber(portNumber > 0 ? portNumber : DEFAULT_PORTNO + 2) { function_table(); - start(); + startTCPSocket(); } -void slsReceiverTCPIPInterface::start() { +void ClientInterface::startTCPSocket() { FILE_LOG(logDEBUG) << "Creating TCP Server Thread"; killTCPServerThread = 0; if (pthread_create(&TCPServer_thread, nullptr, startTCPServerThread, @@ -47,7 +39,7 @@ void slsReceiverTCPIPInterface::start() { FILE_LOG(logDEBUG) << "TCP Server thread created successfully."; } -void slsReceiverTCPIPInterface::stop() { +void ClientInterface::stopTCPSocket() { if (tcpThreadCreated) { FILE_LOG(logINFO) << "Shutting down TCP Socket on port " << portNumber; killTCPServerThread = 1; @@ -62,39 +54,39 @@ void slsReceiverTCPIPInterface::stop() { } } -int64_t slsReceiverTCPIPInterface::getReceiverVersion() { return APIRECEIVER; } +int64_t ClientInterface::getReceiverVersion() { return APIRECEIVER; } /***callback functions***/ -void slsReceiverTCPIPInterface::registerCallBackStartAcquisition( +void ClientInterface::registerCallBackStartAcquisition( int (*func)(std::string, std::string, uint64_t, uint32_t, void *), void *arg) { startAcquisitionCallBack = func; pStartAcquisition = arg; } -void slsReceiverTCPIPInterface::registerCallBackAcquisitionFinished( +void ClientInterface::registerCallBackAcquisitionFinished( void (*func)(uint64_t, void *), void *arg) { acquisitionFinishedCallBack = func; pAcquisitionFinished = arg; } -void slsReceiverTCPIPInterface::registerCallBackRawDataReady( +void ClientInterface::registerCallBackRawDataReady( void (*func)(char *, char *, uint32_t, void *), void *arg) { rawDataReadyCallBack = func; pRawDataReady = arg; } -void slsReceiverTCPIPInterface::registerCallBackRawDataModifyReady( +void ClientInterface::registerCallBackRawDataModifyReady( void (*func)(char *, char *, uint32_t &, void *), void *arg) { rawDataModifyReadyCallBack = func; pRawDataReady = arg; } -void *slsReceiverTCPIPInterface::startTCPServerThread(void *this_pointer) { - ((slsReceiverTCPIPInterface *)this_pointer)->startTCPServer(); +void *ClientInterface::startTCPServerThread(void *this_pointer) { + ((ClientInterface *)this_pointer)->startTCPServer(); return this_pointer; } -void slsReceiverTCPIPInterface::startTCPServer() { +void ClientInterface::startTCPServer() { FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " << syscall(SYS_gettid) << "]"; FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port " @@ -144,72 +136,72 @@ void slsReceiverTCPIPInterface::startTCPServer() { } } // clang-format off -int slsReceiverTCPIPInterface::function_table(){ - flist[F_EXEC_RECEIVER_COMMAND] = &slsReceiverTCPIPInterface::exec_command; - flist[F_EXIT_RECEIVER] = &slsReceiverTCPIPInterface::exit_server; - flist[F_LOCK_RECEIVER] = &slsReceiverTCPIPInterface::lock_receiver; - flist[F_GET_LAST_RECEIVER_CLIENT_IP] = &slsReceiverTCPIPInterface::get_last_client_ip; - flist[F_SET_RECEIVER_PORT] = &slsReceiverTCPIPInterface::set_port; - flist[F_UPDATE_RECEIVER_CLIENT] = &slsReceiverTCPIPInterface::update_client; - flist[F_GET_RECEIVER_VERSION] = &slsReceiverTCPIPInterface::get_version; - flist[F_GET_RECEIVER_TYPE] = &slsReceiverTCPIPInterface::set_detector_type; - flist[F_SEND_RECEIVER_DETHOSTNAME] = &slsReceiverTCPIPInterface::set_detector_hostname; - flist[F_RECEIVER_SET_ROI] = &slsReceiverTCPIPInterface::set_roi; - flist[F_RECEIVER_SET_NUM_FRAMES] = &slsReceiverTCPIPInterface::set_num_frames; - flist[F_RECEIVER_SET_NUM_ANALOG_SAMPLES]= &slsReceiverTCPIPInterface::set_num_analog_samples; - flist[F_RECEIVER_SET_NUM_DIGITAL_SAMPLES]= &slsReceiverTCPIPInterface::set_num_digital_samples; - flist[F_RECEIVER_SET_EXPTIME] = &slsReceiverTCPIPInterface::set_exptime; - flist[F_RECEIVER_SET_PERIOD] = &slsReceiverTCPIPInterface::set_period; - flist[F_RECEIVER_SET_SUB_EXPTIME] = &slsReceiverTCPIPInterface::set_subexptime; - flist[F_RECEIVER_SET_SUB_DEADTIME] = &slsReceiverTCPIPInterface::set_subdeadtime; - flist[F_SET_RECEIVER_DYNAMIC_RANGE] = &slsReceiverTCPIPInterface::set_dynamic_range; - flist[F_RECEIVER_STREAMING_FREQUENCY] = &slsReceiverTCPIPInterface::set_streaming_frequency; - flist[F_GET_RECEIVER_STATUS] = &slsReceiverTCPIPInterface::get_status; - flist[F_START_RECEIVER] = &slsReceiverTCPIPInterface::start_receiver; - flist[F_STOP_RECEIVER] = &slsReceiverTCPIPInterface::stop_receiver; - flist[F_SET_RECEIVER_FILE_PATH] = &slsReceiverTCPIPInterface::set_file_dir; - flist[F_SET_RECEIVER_FILE_NAME] = &slsReceiverTCPIPInterface::set_file_name; - flist[F_SET_RECEIVER_FILE_INDEX] = &slsReceiverTCPIPInterface::set_file_index; - flist[F_GET_RECEIVER_FRAME_INDEX] = &slsReceiverTCPIPInterface::get_frame_index; - flist[F_GET_RECEIVER_FRAMES_CAUGHT] = &slsReceiverTCPIPInterface::get_frames_caught; - flist[F_ENABLE_RECEIVER_FILE_WRITE] = &slsReceiverTCPIPInterface::enable_file_write; - flist[F_ENABLE_RECEIVER_MASTER_FILE_WRITE] = &slsReceiverTCPIPInterface::enable_master_file_write; - flist[F_ENABLE_RECEIVER_OVERWRITE] = &slsReceiverTCPIPInterface::enable_overwrite; - flist[F_ENABLE_RECEIVER_TEN_GIGA] = &slsReceiverTCPIPInterface::enable_tengiga; - flist[F_SET_RECEIVER_FIFO_DEPTH] = &slsReceiverTCPIPInterface::set_fifo_depth; - flist[F_RECEIVER_ACTIVATE] = &slsReceiverTCPIPInterface::set_activate; - flist[F_STREAM_DATA_FROM_RECEIVER] = &slsReceiverTCPIPInterface::set_data_stream_enable; - flist[F_RECEIVER_STREAMING_TIMER] = &slsReceiverTCPIPInterface::set_streaming_timer; - flist[F_SET_FLIPPED_DATA_RECEIVER] = &slsReceiverTCPIPInterface::set_flipped_data; - flist[F_SET_RECEIVER_FILE_FORMAT] = &slsReceiverTCPIPInterface::set_file_format; - flist[F_SEND_RECEIVER_DETPOSID] = &slsReceiverTCPIPInterface::set_detector_posid; - flist[F_SEND_RECEIVER_MULTIDETSIZE] = &slsReceiverTCPIPInterface::set_multi_detector_size; - flist[F_SET_RECEIVER_STREAMING_PORT] = &slsReceiverTCPIPInterface::set_streaming_port; - flist[F_RECEIVER_STREAMING_SRC_IP] = &slsReceiverTCPIPInterface::set_streaming_source_ip; - flist[F_SET_RECEIVER_SILENT_MODE] = &slsReceiverTCPIPInterface::set_silent_mode; - flist[F_ENABLE_GAPPIXELS_IN_RECEIVER] = &slsReceiverTCPIPInterface::enable_gap_pixels; - flist[F_RESTREAM_STOP_FROM_RECEIVER] = &slsReceiverTCPIPInterface::restream_stop; - flist[F_ADDITIONAL_JSON_HEADER] = &slsReceiverTCPIPInterface::set_additional_json_header; - flist[F_GET_ADDITIONAL_JSON_HEADER] = &slsReceiverTCPIPInterface::get_additional_json_header; - flist[F_RECEIVER_UDP_SOCK_BUF_SIZE] = &slsReceiverTCPIPInterface::set_udp_socket_buffer_size; - flist[F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE]= &slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size; - flist[F_SET_RECEIVER_FRAMES_PER_FILE] = &slsReceiverTCPIPInterface::set_frames_per_file; - flist[F_RECEIVER_CHECK_VERSION] = &slsReceiverTCPIPInterface::check_version_compatibility; - flist[F_RECEIVER_DISCARD_POLICY] = &slsReceiverTCPIPInterface::set_discard_policy; - flist[F_RECEIVER_PADDING_ENABLE] = &slsReceiverTCPIPInterface::set_padding_enable; - flist[F_RECEIVER_DEACTIVATED_PADDING_ENABLE] = &slsReceiverTCPIPInterface::set_deactivated_padding_enable; - flist[F_RECEIVER_SET_READOUT_MODE] = &slsReceiverTCPIPInterface::set_readout_mode; - flist[F_RECEIVER_SET_ADC_MASK] = &slsReceiverTCPIPInterface::set_adc_mask; - flist[F_SET_RECEIVER_DBIT_LIST] = &slsReceiverTCPIPInterface::set_dbit_list; - flist[F_GET_RECEIVER_DBIT_LIST] = &slsReceiverTCPIPInterface::get_dbit_list; - flist[F_RECEIVER_DBIT_OFFSET] = &slsReceiverTCPIPInterface::set_dbit_offset; - flist[F_SET_RECEIVER_QUAD] = &slsReceiverTCPIPInterface::set_quad_type; - flist[F_SET_RECEIVER_READ_N_LINES] = &slsReceiverTCPIPInterface::set_read_n_lines; - flist[F_SET_RECEIVER_UDP_IP] = &slsReceiverTCPIPInterface::set_udp_ip; - flist[F_SET_RECEIVER_UDP_IP2] = &slsReceiverTCPIPInterface::set_udp_ip2; - flist[F_SET_RECEIVER_UDP_PORT] = &slsReceiverTCPIPInterface::set_udp_port; - flist[F_SET_RECEIVER_UDP_PORT2] = &slsReceiverTCPIPInterface::set_udp_port2; - flist[F_SET_RECEIVER_NUM_INTERFACES] = &slsReceiverTCPIPInterface::set_num_interfaces; +int ClientInterface::function_table(){ + flist[F_EXEC_RECEIVER_COMMAND] = &ClientInterface::exec_command; + flist[F_EXIT_RECEIVER] = &ClientInterface::exit_server; + flist[F_LOCK_RECEIVER] = &ClientInterface::lock_receiver; + flist[F_GET_LAST_RECEIVER_CLIENT_IP] = &ClientInterface::get_last_client_ip; + flist[F_SET_RECEIVER_PORT] = &ClientInterface::set_port; + flist[F_UPDATE_RECEIVER_CLIENT] = &ClientInterface::update_client; + flist[F_GET_RECEIVER_VERSION] = &ClientInterface::get_version; + flist[F_GET_RECEIVER_TYPE] = &ClientInterface::set_detector_type; + flist[F_SEND_RECEIVER_DETHOSTNAME] = &ClientInterface::set_detector_hostname; + flist[F_RECEIVER_SET_ROI] = &ClientInterface::set_roi; + flist[F_RECEIVER_SET_NUM_FRAMES] = &ClientInterface::set_num_frames; + flist[F_RECEIVER_SET_NUM_ANALOG_SAMPLES]= &ClientInterface::set_num_analog_samples; + flist[F_RECEIVER_SET_NUM_DIGITAL_SAMPLES]= &ClientInterface::set_num_digital_samples; + flist[F_RECEIVER_SET_EXPTIME] = &ClientInterface::set_exptime; + flist[F_RECEIVER_SET_PERIOD] = &ClientInterface::set_period; + flist[F_RECEIVER_SET_SUB_EXPTIME] = &ClientInterface::set_subexptime; + flist[F_RECEIVER_SET_SUB_DEADTIME] = &ClientInterface::set_subdeadtime; + flist[F_SET_RECEIVER_DYNAMIC_RANGE] = &ClientInterface::set_dynamic_range; + flist[F_RECEIVER_STREAMING_FREQUENCY] = &ClientInterface::set_streaming_frequency; + flist[F_GET_RECEIVER_STATUS] = &ClientInterface::get_status; + flist[F_START_RECEIVER] = &ClientInterface::start_receiver; + flist[F_STOP_RECEIVER] = &ClientInterface::stop_receiver; + flist[F_SET_RECEIVER_FILE_PATH] = &ClientInterface::set_file_dir; + flist[F_SET_RECEIVER_FILE_NAME] = &ClientInterface::set_file_name; + flist[F_SET_RECEIVER_FILE_INDEX] = &ClientInterface::set_file_index; + flist[F_GET_RECEIVER_FRAME_INDEX] = &ClientInterface::get_frame_index; + flist[F_GET_RECEIVER_FRAMES_CAUGHT] = &ClientInterface::get_frames_caught; + flist[F_ENABLE_RECEIVER_FILE_WRITE] = &ClientInterface::enable_file_write; + flist[F_ENABLE_RECEIVER_MASTER_FILE_WRITE] = &ClientInterface::enable_master_file_write; + flist[F_ENABLE_RECEIVER_OVERWRITE] = &ClientInterface::enable_overwrite; + flist[F_ENABLE_RECEIVER_TEN_GIGA] = &ClientInterface::enable_tengiga; + flist[F_SET_RECEIVER_FIFO_DEPTH] = &ClientInterface::set_fifo_depth; + flist[F_RECEIVER_ACTIVATE] = &ClientInterface::set_activate; + flist[F_STREAM_DATA_FROM_RECEIVER] = &ClientInterface::set_data_stream_enable; + flist[F_RECEIVER_STREAMING_TIMER] = &ClientInterface::set_streaming_timer; + flist[F_SET_FLIPPED_DATA_RECEIVER] = &ClientInterface::set_flipped_data; + flist[F_SET_RECEIVER_FILE_FORMAT] = &ClientInterface::set_file_format; + flist[F_SEND_RECEIVER_DETPOSID] = &ClientInterface::set_detector_posid; + flist[F_SEND_RECEIVER_MULTIDETSIZE] = &ClientInterface::set_multi_detector_size; + flist[F_SET_RECEIVER_STREAMING_PORT] = &ClientInterface::set_streaming_port; + flist[F_RECEIVER_STREAMING_SRC_IP] = &ClientInterface::set_streaming_source_ip; + flist[F_SET_RECEIVER_SILENT_MODE] = &ClientInterface::set_silent_mode; + flist[F_ENABLE_GAPPIXELS_IN_RECEIVER] = &ClientInterface::enable_gap_pixels; + flist[F_RESTREAM_STOP_FROM_RECEIVER] = &ClientInterface::restream_stop; + flist[F_ADDITIONAL_JSON_HEADER] = &ClientInterface::set_additional_json_header; + flist[F_GET_ADDITIONAL_JSON_HEADER] = &ClientInterface::get_additional_json_header; + flist[F_RECEIVER_UDP_SOCK_BUF_SIZE] = &ClientInterface::set_udp_socket_buffer_size; + flist[F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE]= &ClientInterface::get_real_udp_socket_buffer_size; + flist[F_SET_RECEIVER_FRAMES_PER_FILE] = &ClientInterface::set_frames_per_file; + flist[F_RECEIVER_CHECK_VERSION] = &ClientInterface::check_version_compatibility; + flist[F_RECEIVER_DISCARD_POLICY] = &ClientInterface::set_discard_policy; + flist[F_RECEIVER_PADDING_ENABLE] = &ClientInterface::set_padding_enable; + flist[F_RECEIVER_DEACTIVATED_PADDING_ENABLE] = &ClientInterface::set_deactivated_padding_enable; + flist[F_RECEIVER_SET_READOUT_MODE] = &ClientInterface::set_readout_mode; + flist[F_RECEIVER_SET_ADC_MASK] = &ClientInterface::set_adc_mask; + flist[F_SET_RECEIVER_DBIT_LIST] = &ClientInterface::set_dbit_list; + flist[F_GET_RECEIVER_DBIT_LIST] = &ClientInterface::get_dbit_list; + flist[F_RECEIVER_DBIT_OFFSET] = &ClientInterface::set_dbit_offset; + flist[F_SET_RECEIVER_QUAD] = &ClientInterface::set_quad_type; + flist[F_SET_RECEIVER_READ_N_LINES] = &ClientInterface::set_read_n_lines; + flist[F_SET_RECEIVER_UDP_IP] = &ClientInterface::set_udp_ip; + flist[F_SET_RECEIVER_UDP_IP2] = &ClientInterface::set_udp_ip2; + flist[F_SET_RECEIVER_UDP_PORT] = &ClientInterface::set_udp_port; + flist[F_SET_RECEIVER_UDP_PORT2] = &ClientInterface::set_udp_port2; + flist[F_SET_RECEIVER_NUM_INTERFACES] = &ClientInterface::set_num_interfaces; for (int i = NUM_DET_FUNCTIONS + 1; i < NUM_REC_FUNCTIONS ; i++) { // FILE_LOG(logDEBUG1) << "function fnum: " << i << " (" << @@ -219,7 +211,7 @@ int slsReceiverTCPIPInterface::function_table(){ return OK; } // clang-format on -int slsReceiverTCPIPInterface::decode_function(Interface &socket) { +int ClientInterface::decode_function(Interface &socket) { ret = FAIL; socket.Receive(fnum); if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) { @@ -237,14 +229,14 @@ int slsReceiverTCPIPInterface::decode_function(Interface &socket) { return ret; } -void slsReceiverTCPIPInterface::functionNotImplemented() { +void ClientInterface::functionNotImplemented() { std::ostringstream os; // os << "Function: " << getFunctionNameFromEnum((enum detFuncs)fnum) // << ", is is not implemented for this detector"; throw RuntimeError(os.str()); } -void slsReceiverTCPIPInterface::modeNotImplemented(const std::string &modename, +void ClientInterface::modeNotImplemented(const std::string &modename, int mode) { std::ostringstream os; os << modename << " (" << mode << ") is not implemented for this detector"; @@ -252,7 +244,7 @@ void slsReceiverTCPIPInterface::modeNotImplemented(const std::string &modename, } template -void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename, +void ClientInterface::validate(T arg, T retval, std::string modename, numberMode hex) { if (ret == OK && arg != -1 && retval != arg) { auto format = (hex == HEX) ? std::hex : std::dec; @@ -264,13 +256,13 @@ void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename, } } -void slsReceiverTCPIPInterface::VerifyLock() { +void ClientInterface::VerifyLock() { if (lockStatus && server->getThisClient() != server->getLockedBy()) { throw sls::SocketError("Receiver locked\n"); } } -void slsReceiverTCPIPInterface::VerifyIdle(Interface &socket) { +void ClientInterface::VerifyIdle(Interface &socket) { if (impl()->getStatus() != IDLE) { std::ostringstream oss; oss << "Can not execute " << getFunctionNameFromEnum((enum detFuncs)fnum) @@ -279,7 +271,7 @@ void slsReceiverTCPIPInterface::VerifyIdle(Interface &socket) { } } -int slsReceiverTCPIPInterface::exec_command(Interface &socket) { +int ClientInterface::exec_command(Interface &socket) { char cmd[MAX_STR_LENGTH]{}; char retval[MAX_STR_LENGTH]{}; socket.Receive(cmd); @@ -301,13 +293,13 @@ int slsReceiverTCPIPInterface::exec_command(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::exit_server(Interface &socket) { +int ClientInterface::exit_server(Interface &socket) { FILE_LOG(logINFO) << "Closing server"; socket.Send(OK); return GOODBYE; } -int slsReceiverTCPIPInterface::lock_receiver(Interface &socket) { +int ClientInterface::lock_receiver(Interface &socket) { auto lock = socket.Receive(); FILE_LOG(logDEBUG1) << "Locking Server to " << lock; if (lock >= 0) { @@ -322,11 +314,11 @@ int slsReceiverTCPIPInterface::lock_receiver(Interface &socket) { return socket.sendResult(lockStatus); } -int slsReceiverTCPIPInterface::get_last_client_ip(Interface &socket) { +int ClientInterface::get_last_client_ip(Interface &socket) { return socket.sendResult(server->getLastClient()); } -int slsReceiverTCPIPInterface::set_port(Interface &socket) { +int ClientInterface::set_port(Interface &socket) { auto p_number = socket.Receive(); if (p_number < 1024) throw RuntimeError("Port Number: " + std::to_string(p_number) + @@ -341,7 +333,7 @@ int slsReceiverTCPIPInterface::set_port(Interface &socket) { return OK; } -int slsReceiverTCPIPInterface::update_client(Interface &socket) { +int ClientInterface::update_client(Interface &socket) { if (receiver == nullptr) throw sls::SocketError( "Receiver not set up. Please use rx_hostname first.\n"); @@ -349,7 +341,7 @@ int slsReceiverTCPIPInterface::update_client(Interface &socket) { return send_update(socket); } -int slsReceiverTCPIPInterface::send_update(Interface &socket) { +int ClientInterface::send_update(Interface &socket) { int n = 0; int i32 = -1; int64_t i64 = -1; @@ -452,11 +444,11 @@ int slsReceiverTCPIPInterface::send_update(Interface &socket) { return OK; } -int slsReceiverTCPIPInterface::get_version(Interface &socket) { +int ClientInterface::get_version(Interface &socket) { return socket.sendResult(getReceiverVersion()); } -int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) { +int ClientInterface::set_detector_type(Interface &socket) { auto arg = socket.Receive(); // set if (arg >= 0) { @@ -479,7 +471,7 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) { } if (receiver == nullptr) { - receiver = sls::make_unique(); + receiver = sls::make_unique(); } myDetectorType = arg; if (impl()->setDetectorType(myDetectorType) == FAIL) { @@ -503,7 +495,7 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) { return socket.sendResult(myDetectorType); } -int slsReceiverTCPIPInterface::set_detector_hostname(Interface &socket) { +int ClientInterface::set_detector_hostname(Interface &socket) { char hostname[MAX_STR_LENGTH]{}; char retval[MAX_STR_LENGTH]{}; socket.Receive(hostname); @@ -520,7 +512,7 @@ int slsReceiverTCPIPInterface::set_detector_hostname(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_roi(Interface &socket) { +int ClientInterface::set_roi(Interface &socket) { static_assert(sizeof(ROI) == 2 * sizeof(int), "ROI not packed"); ROI arg; socket.Receive(arg); @@ -535,14 +527,14 @@ int slsReceiverTCPIPInterface::set_roi(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_num_frames(Interface &socket) { +int ClientInterface::set_num_frames(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting num frames to " << value; impl()->setNumberOfFrames(value); return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_num_analog_samples(Interface &socket) { +int ClientInterface::set_num_analog_samples(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting num analog samples to " << value; if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) { @@ -553,7 +545,7 @@ int slsReceiverTCPIPInterface::set_num_analog_samples(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_num_digital_samples(Interface &socket) { +int ClientInterface::set_num_digital_samples(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting num digital samples to " << value; if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) { @@ -563,28 +555,28 @@ int slsReceiverTCPIPInterface::set_num_digital_samples(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_exptime(Interface &socket) { +int ClientInterface::set_exptime(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting exptime to " << value << "ns"; impl()->setAcquisitionTime(value); return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_period(Interface &socket) { +int ClientInterface::set_period(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting period to " << value << "ns"; impl()->setAcquisitionPeriod(value); return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_subexptime(Interface &socket) { +int ClientInterface::set_subexptime(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting period to " << value << "ns"; impl()->setSubExpTime(value); return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_subdeadtime(Interface &socket) { +int ClientInterface::set_subdeadtime(Interface &socket) { auto value = socket.Receive(); FILE_LOG(logDEBUG1) << "Setting sub deadtime to " << value << "ns"; impl()->setSubPeriod(value + impl()->getSubExpTime()); @@ -592,7 +584,7 @@ int slsReceiverTCPIPInterface::set_subdeadtime(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_dynamic_range(Interface &socket) { +int ClientInterface::set_dynamic_range(Interface &socket) { auto dr = socket.Receive(); if (dr >= 0) { VerifyIdle(socket); @@ -631,7 +623,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_streaming_frequency(Interface &socket) { +int ClientInterface::set_streaming_frequency(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -646,13 +638,13 @@ int slsReceiverTCPIPInterface::set_streaming_frequency(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::get_status(Interface &socket) { +int ClientInterface::get_status(Interface &socket) { auto retval = impl()->getStatus(); FILE_LOG(logDEBUG1) << "Status:" << sls::ToString(retval); return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::start_receiver(Interface &socket) { +int ClientInterface::start_receiver(Interface &socket) { if (impl()->getStatus() == IDLE) { FILE_LOG(logDEBUG1) << "Starting Receiver"; std::string err; @@ -664,7 +656,7 @@ int slsReceiverTCPIPInterface::start_receiver(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::stop_receiver(Interface &socket) { +int ClientInterface::stop_receiver(Interface &socket) { if (impl()->getStatus() == RUNNING) { FILE_LOG(logDEBUG1) << "Stopping Receiver"; impl()->stopReceiver(); @@ -677,7 +669,7 @@ int slsReceiverTCPIPInterface::stop_receiver(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_file_dir(Interface &socket) { +int ClientInterface::set_file_dir(Interface &socket) { char fPath[MAX_STR_LENGTH]{}; char retval[MAX_STR_LENGTH]{}; socket.Receive(fPath); @@ -698,7 +690,7 @@ int slsReceiverTCPIPInterface::set_file_dir(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_file_name(Interface &socket) { +int ClientInterface::set_file_name(Interface &socket) { char fName[MAX_STR_LENGTH]{}; char retval[MAX_STR_LENGTH]{}; socket.Receive(fName); @@ -715,7 +707,7 @@ int slsReceiverTCPIPInterface::set_file_name(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_file_index(Interface &socket) { +int ClientInterface::set_file_index(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -728,19 +720,19 @@ int slsReceiverTCPIPInterface::set_file_index(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::get_frame_index(Interface &socket) { +int ClientInterface::get_frame_index(Interface &socket) { uint64_t retval = impl()->getAcquisitionIndex(); FILE_LOG(logDEBUG1) << "frame index:" << retval; return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::get_frames_caught(Interface &socket) { +int ClientInterface::get_frames_caught(Interface &socket) { int64_t retval = impl()->getFramesCaught(); FILE_LOG(logDEBUG1) << "frames caught:" << retval; return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::enable_file_write(Interface &socket) { +int ClientInterface::enable_file_write(Interface &socket) { auto enable = socket.Receive(); if (enable >= 0) { VerifyIdle(socket); @@ -753,7 +745,7 @@ int slsReceiverTCPIPInterface::enable_file_write(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket) { +int ClientInterface::enable_master_file_write(Interface &socket) { auto enable = socket.Receive(); if (enable >= 0) { VerifyIdle(socket); @@ -766,7 +758,7 @@ int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) { +int ClientInterface::enable_overwrite(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -779,7 +771,7 @@ int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::enable_tengiga(Interface &socket) { +int ClientInterface::enable_tengiga(Interface &socket) { auto val = socket.Receive(); if (myDetectorType != EIGER && myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) @@ -796,7 +788,7 @@ int slsReceiverTCPIPInterface::enable_tengiga(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_fifo_depth(Interface &socket) { +int ClientInterface::set_fifo_depth(Interface &socket) { auto value = socket.Receive(); if (value >= 0) { VerifyIdle(socket); @@ -809,7 +801,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_activate(Interface &socket) { +int ClientInterface::set_activate(Interface &socket) { auto enable = socket.Receive(); if (myDetectorType != EIGER) functionNotImplemented(); @@ -825,7 +817,7 @@ int slsReceiverTCPIPInterface::set_activate(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_data_stream_enable(Interface &socket) { +int ClientInterface::set_data_stream_enable(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -838,7 +830,7 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket) { +int ClientInterface::set_streaming_timer(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -851,7 +843,7 @@ int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket) { +int ClientInterface::set_flipped_data(Interface &socket) { auto arg = socket.Receive(); if (myDetectorType != EIGER) @@ -868,7 +860,7 @@ int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_file_format(Interface &socket) { +int ClientInterface::set_file_format(Interface &socket) { fileFormat f = GET_FILE_FORMAT; socket.Receive(f); if (f >= 0) { @@ -882,7 +874,7 @@ int slsReceiverTCPIPInterface::set_file_format(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_detector_posid(Interface &socket) { +int ClientInterface::set_detector_posid(Interface &socket) { auto arg = socket.Receive(); if (arg >= 0) { VerifyIdle(socket); @@ -895,7 +887,7 @@ int slsReceiverTCPIPInterface::set_detector_posid(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_multi_detector_size(Interface &socket) { +int ClientInterface::set_multi_detector_size(Interface &socket) { int arg[]{-1, -1}; socket.Receive(arg); if ((arg[0] > 0) && (arg[1] > 0)) { @@ -910,7 +902,7 @@ int slsReceiverTCPIPInterface::set_multi_detector_size(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_streaming_port(Interface &socket) { +int ClientInterface::set_streaming_port(Interface &socket) { auto port = socket.Receive(); if (port >= 0) { VerifyIdle(socket); @@ -923,7 +915,7 @@ int slsReceiverTCPIPInterface::set_streaming_port(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_streaming_source_ip(Interface &socket) { +int ClientInterface::set_streaming_source_ip(Interface &socket) { sls::IpAddr arg = 0u; socket.Receive(arg); VerifyIdle(socket); @@ -939,7 +931,7 @@ int slsReceiverTCPIPInterface::set_streaming_source_ip(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_silent_mode(Interface &socket) { +int ClientInterface::set_silent_mode(Interface &socket) { auto value = socket.Receive(); if (value >= 0) { VerifyIdle(socket); @@ -952,7 +944,7 @@ int slsReceiverTCPIPInterface::set_silent_mode(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::enable_gap_pixels(Interface &socket) { +int ClientInterface::enable_gap_pixels(Interface &socket) { auto enable = socket.Receive(); if (myDetectorType != EIGER) functionNotImplemented(); @@ -968,7 +960,7 @@ int slsReceiverTCPIPInterface::enable_gap_pixels(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::restream_stop(Interface &socket) { +int ClientInterface::restream_stop(Interface &socket) { VerifyIdle(socket); if (!impl()->getDataStreamEnable()) { throw RuntimeError( @@ -980,7 +972,7 @@ int slsReceiverTCPIPInterface::restream_stop(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_additional_json_header(Interface &socket) { +int ClientInterface::set_additional_json_header(Interface &socket) { char arg[MAX_STR_LENGTH]{}; char retval[MAX_STR_LENGTH]{}; socket.Receive(arg); @@ -992,14 +984,14 @@ int slsReceiverTCPIPInterface::set_additional_json_header(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::get_additional_json_header(Interface &socket) { +int ClientInterface::get_additional_json_header(Interface &socket) { char retval[MAX_STR_LENGTH]{}; sls::strcpy_safe(retval, impl()->getAdditionalJsonHeader().c_str()); FILE_LOG(logDEBUG1) << "additional json header:" << retval; return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_udp_socket_buffer_size(Interface &socket) { +int ClientInterface::set_udp_socket_buffer_size(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -1018,14 +1010,14 @@ int slsReceiverTCPIPInterface::set_udp_socket_buffer_size(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size( +int ClientInterface::get_real_udp_socket_buffer_size( Interface &socket) { auto size = impl()->getActualUDPSocketBufferSize(); FILE_LOG(logDEBUG1) << "Actual UDP socket size :" << size; return socket.sendResult(size); } -int slsReceiverTCPIPInterface::set_frames_per_file(Interface &socket) { +int ClientInterface::set_frames_per_file(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -1038,7 +1030,7 @@ int slsReceiverTCPIPInterface::set_frames_per_file(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) { +int ClientInterface::check_version_compatibility(Interface &socket) { auto arg = socket.Receive(); FILE_LOG(logDEBUG1) << "Checking versioning compatibility with value " << arg; @@ -1066,7 +1058,7 @@ int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_discard_policy(Interface &socket) { +int ClientInterface::set_discard_policy(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -1079,7 +1071,7 @@ int slsReceiverTCPIPInterface::set_discard_policy(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_padding_enable(Interface &socket) { +int ClientInterface::set_padding_enable(Interface &socket) { auto index = socket.Receive(); if (index >= 0) { VerifyIdle(socket); @@ -1092,7 +1084,7 @@ int slsReceiverTCPIPInterface::set_padding_enable(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_deactivated_padding_enable( +int ClientInterface::set_deactivated_padding_enable( Interface &socket) { auto enable = socket.Receive(); if (myDetectorType != EIGER) @@ -1109,7 +1101,7 @@ int slsReceiverTCPIPInterface::set_deactivated_padding_enable( return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_readout_mode(Interface &socket) { +int ClientInterface::set_readout_mode(Interface &socket) { auto arg = socket.Receive(); if (myDetectorType != CHIPTESTBOARD) @@ -1127,7 +1119,7 @@ int slsReceiverTCPIPInterface::set_readout_mode(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_adc_mask(Interface &socket) { +int ClientInterface::set_adc_mask(Interface &socket) { auto arg = socket.Receive(); VerifyIdle(socket); FILE_LOG(logDEBUG1) << "Setting ADC enable mask: " << arg; @@ -1143,7 +1135,7 @@ int slsReceiverTCPIPInterface::set_adc_mask(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_dbit_list(Interface &socket) { +int ClientInterface::set_dbit_list(Interface &socket) { sls::FixedCapacityContainer args; socket.Receive(args); FILE_LOG(logDEBUG1) << "Setting DBIT list"; @@ -1156,14 +1148,14 @@ int slsReceiverTCPIPInterface::set_dbit_list(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::get_dbit_list(Interface &socket) { +int ClientInterface::get_dbit_list(Interface &socket) { sls::FixedCapacityContainer retval; retval = impl()->getDbitList(); FILE_LOG(logDEBUG1) << "Dbit list size retval:" << retval.size(); return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_dbit_offset(Interface &socket) { +int ClientInterface::set_dbit_offset(Interface &socket) { auto arg = socket.Receive(); if (arg >= 0) { VerifyIdle(socket); @@ -1176,7 +1168,7 @@ int slsReceiverTCPIPInterface::set_dbit_offset(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_quad_type(Interface &socket) { +int ClientInterface::set_quad_type(Interface &socket) { auto quadEnable = socket.Receive(); if (quadEnable >= 0) { VerifyIdle(socket); @@ -1192,7 +1184,7 @@ int slsReceiverTCPIPInterface::set_quad_type(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_read_n_lines(Interface &socket) { +int ClientInterface::set_read_n_lines(Interface &socket) { auto arg = socket.Receive(); if (arg >= 0) { VerifyIdle(socket); @@ -1206,7 +1198,7 @@ int slsReceiverTCPIPInterface::set_read_n_lines(Interface &socket) { } -int slsReceiverTCPIPInterface::set_udp_ip(Interface &socket) { +int ClientInterface::set_udp_ip(Interface &socket) { auto arg = socket.Receive(); VerifyIdle(socket); FILE_LOG(logINFO) << "Received UDP IP: " << arg; @@ -1233,7 +1225,7 @@ int slsReceiverTCPIPInterface::set_udp_ip(Interface &socket) { } -int slsReceiverTCPIPInterface::set_udp_ip2(Interface &socket) { +int ClientInterface::set_udp_ip2(Interface &socket) { auto arg = socket.Receive(); VerifyIdle(socket); if (myDetectorType != JUNGFRAU) { @@ -1260,7 +1252,7 @@ int slsReceiverTCPIPInterface::set_udp_ip2(Interface &socket) { return socket.sendResult(retval); } -int slsReceiverTCPIPInterface::set_udp_port(Interface &socket) { +int ClientInterface::set_udp_port(Interface &socket) { auto arg = socket.Receive(); VerifyIdle(socket); FILE_LOG(logDEBUG1) << "Setting UDP Port:" << arg; @@ -1268,7 +1260,7 @@ int slsReceiverTCPIPInterface::set_udp_port(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_udp_port2(Interface &socket) { +int ClientInterface::set_udp_port2(Interface &socket) { auto arg = socket.Receive(); VerifyIdle(socket); if (myDetectorType != JUNGFRAU && myDetectorType != EIGER) { @@ -1279,7 +1271,7 @@ int slsReceiverTCPIPInterface::set_udp_port2(Interface &socket) { return socket.Send(OK); } -int slsReceiverTCPIPInterface::set_num_interfaces(Interface &socket) { +int ClientInterface::set_num_interfaces(Interface &socket) { auto arg = socket.Receive(); arg = (arg > 1 ? 2 : 1); VerifyIdle(socket); diff --git a/slsReceiverSoftware/src/slsReceiverImplementation.cpp b/slsReceiverSoftware/src/Implementation.cpp similarity index 85% rename from slsReceiverSoftware/src/slsReceiverImplementation.cpp rename to slsReceiverSoftware/src/Implementation.cpp index 97b2467f6..5be97e005 100755 --- a/slsReceiverSoftware/src/slsReceiverImplementation.cpp +++ b/slsReceiverSoftware/src/Implementation.cpp @@ -1,4 +1,4 @@ -#include "slsReceiverImplementation.h" +#include "Implementation.h" #include "DataProcessor.h" #include "DataStreamer.h" #include "Fifo.h" @@ -18,17 +18,17 @@ /** cosntructor & destructor */ -slsReceiverImplementation::slsReceiverImplementation() { +Implementation::Implementation() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; InitializeMembers(); } -slsReceiverImplementation::~slsReceiverImplementation() { +Implementation::~Implementation() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; DeleteMembers(); } -void slsReceiverImplementation::DeleteMembers() { +void Implementation::DeleteMembers() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; if (generalData) { delete generalData; @@ -42,7 +42,7 @@ void slsReceiverImplementation::DeleteMembers() { ctbDbitList.clear(); } -void slsReceiverImplementation::InitializeMembers() { +void Implementation::InitializeMembers() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; //**detector parameters*** myDetectorType = GENERIC; @@ -123,101 +123,101 @@ void slsReceiverImplementation::InitializeMembers() { *************************************************************************/ /**initial parameters***/ -int *slsReceiverImplementation::getMultiDetectorSize() const { +int *Implementation::getMultiDetectorSize() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return (int *)numDet; } -int slsReceiverImplementation::getDetectorPositionId() const { +int Implementation::getDetectorPositionId() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return detID; } -std::string slsReceiverImplementation::getDetectorHostname() const { +std::string Implementation::getDetectorHostname() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return detHostname; } -int slsReceiverImplementation::getFlippedDataX() const { +int Implementation::getFlippedDataX() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return flippedDataX; } -bool slsReceiverImplementation::getGapPixelsEnable() const { +bool Implementation::getGapPixelsEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return gapPixelsEnable; } -bool slsReceiverImplementation::getQuad() const { +bool Implementation::getQuad() const { FILE_LOG(logDEBUG) << __AT__ << " starting"; return quadEnable; } -int slsReceiverImplementation::getReadNLines() const { +int Implementation::getReadNLines() const { FILE_LOG(logDEBUG) << __AT__ << " starting"; return numLinesReadout; } slsDetectorDefs::readoutMode -slsReceiverImplementation::getReadoutMode() const { +Implementation::getReadoutMode() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return readoutType; } /***file parameters***/ -slsDetectorDefs::fileFormat slsReceiverImplementation::getFileFormat() const { +slsDetectorDefs::fileFormat Implementation::getFileFormat() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return fileFormatType; } -std::string slsReceiverImplementation::getFileName() const { +std::string Implementation::getFileName() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return fileName; } -std::string slsReceiverImplementation::getFilePath() const { +std::string Implementation::getFilePath() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return filePath; } -uint64_t slsReceiverImplementation::getFileIndex() const { +uint64_t Implementation::getFileIndex() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return fileIndex; } -uint32_t slsReceiverImplementation::getFramesPerFile() const { +uint32_t Implementation::getFramesPerFile() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return framesPerFile; } slsDetectorDefs::frameDiscardPolicy -slsReceiverImplementation::getFrameDiscardPolicy() const { +Implementation::getFrameDiscardPolicy() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return frameDiscardMode; } -bool slsReceiverImplementation::getFramePaddingEnable() const { +bool Implementation::getFramePaddingEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return framePadding; } -bool slsReceiverImplementation::getFileWriteEnable() const { +bool Implementation::getFileWriteEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return fileWriteEnable; } -bool slsReceiverImplementation::getMasterFileWriteEnable() const { +bool Implementation::getMasterFileWriteEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return masterFileWriteEnable; } -bool slsReceiverImplementation::getOverwriteEnable() const { +bool Implementation::getOverwriteEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return overwriteEnable; } /***acquisition count parameters***/ -uint64_t slsReceiverImplementation::getFramesCaught() const { +uint64_t Implementation::getFramesCaught() const { uint64_t min = -1; uint32_t flagsum = 0; @@ -233,7 +233,7 @@ uint64_t slsReceiverImplementation::getFramesCaught() const { return min; } -uint64_t slsReceiverImplementation::getAcquisitionIndex() const { +uint64_t Implementation::getAcquisitionIndex() const { uint64_t min = -1; uint32_t flagsum = 0; @@ -250,159 +250,159 @@ uint64_t slsReceiverImplementation::getAcquisitionIndex() const { } /***connection parameters***/ -uint32_t slsReceiverImplementation::getUDPPortNumber() const { +uint32_t Implementation::getUDPPortNumber() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return udpPortNum[0]; } -uint32_t slsReceiverImplementation::getUDPPortNumber2() const { +uint32_t Implementation::getUDPPortNumber2() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return udpPortNum[1]; } -std::string slsReceiverImplementation::getEthernetInterface() const { +std::string Implementation::getEthernetInterface() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return eth[0]; } -std::string slsReceiverImplementation::getEthernetInterface2() const { +std::string Implementation::getEthernetInterface2() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return eth[1]; } -int slsReceiverImplementation::getNumberofUDPInterfaces() const { +int Implementation::getNumberofUDPInterfaces() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return numUDPInterfaces; } /***acquisition parameters***/ -slsDetectorDefs::ROI slsReceiverImplementation::getROI() const { +slsDetectorDefs::ROI Implementation::getROI() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return roi; } -uint32_t slsReceiverImplementation::getADCEnableMask() const { +uint32_t Implementation::getADCEnableMask() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return adcEnableMask; } -uint32_t slsReceiverImplementation::getStreamingFrequency() const { +uint32_t Implementation::getStreamingFrequency() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return streamingFrequency; } -uint32_t slsReceiverImplementation::getStreamingTimer() const { +uint32_t Implementation::getStreamingTimer() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return streamingTimerInMs; } -bool slsReceiverImplementation::getDataStreamEnable() const { +bool Implementation::getDataStreamEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return dataStreamEnable; } -uint64_t slsReceiverImplementation::getAcquisitionPeriod() const { +uint64_t Implementation::getAcquisitionPeriod() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return acquisitionPeriod; } -uint64_t slsReceiverImplementation::getAcquisitionTime() const { +uint64_t Implementation::getAcquisitionTime() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return acquisitionTime; } -uint64_t slsReceiverImplementation::getSubExpTime() const { +uint64_t Implementation::getSubExpTime() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return subExpTime; } -uint64_t slsReceiverImplementation::getSubPeriod() const { +uint64_t Implementation::getSubPeriod() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return subPeriod; } -uint64_t slsReceiverImplementation::getNumberOfFrames() const { +uint64_t Implementation::getNumberOfFrames() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return numberOfFrames; } -uint32_t slsReceiverImplementation::getNumberofAnalogSamples() const { +uint32_t Implementation::getNumberofAnalogSamples() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return numberOfAnalogSamples; } -uint32_t slsReceiverImplementation::getNumberofDigitalSamples() const { +uint32_t Implementation::getNumberofDigitalSamples() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return numberOfDigitalSamples; } -uint32_t slsReceiverImplementation::getDynamicRange() const { +uint32_t Implementation::getDynamicRange() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return dynamicRange; } -bool slsReceiverImplementation::getTenGigaEnable() const { +bool Implementation::getTenGigaEnable() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return tengigaEnable; } -uint32_t slsReceiverImplementation::getFifoDepth() const { +uint32_t Implementation::getFifoDepth() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return fifoDepth; } /***receiver status***/ -slsDetectorDefs::runStatus slsReceiverImplementation::getStatus() const { +slsDetectorDefs::runStatus Implementation::getStatus() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return status; } -bool slsReceiverImplementation::getSilentMode() const { +bool Implementation::getSilentMode() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return silentMode; } -std::vector slsReceiverImplementation::getDbitList() const { +std::vector Implementation::getDbitList() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return ctbDbitList; } -int slsReceiverImplementation::getDbitOffset() const { +int Implementation::getDbitOffset() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return ctbDbitOffset; } -bool slsReceiverImplementation::getActivate() const { +bool Implementation::getActivate() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return activated; } -bool slsReceiverImplementation::getDeactivatedPadding() const { +bool Implementation::getDeactivatedPadding() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return deactivatedPaddingEnable; } -uint32_t slsReceiverImplementation::getStreamingPort() const { +uint32_t Implementation::getStreamingPort() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return streamingPort; } -sls::IpAddr slsReceiverImplementation::getStreamingSourceIP() const { +sls::IpAddr Implementation::getStreamingSourceIP() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return streamingSrcIP; } -std::string slsReceiverImplementation::getAdditionalJsonHeader() const { +std::string Implementation::getAdditionalJsonHeader() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return additionalJsonHeader; } -int64_t slsReceiverImplementation::getUDPSocketBufferSize() const { +int64_t Implementation::getUDPSocketBufferSize() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return udpSocketBufferSize; } -int64_t slsReceiverImplementation::getActualUDPSocketBufferSize() const { +int64_t Implementation::getActualUDPSocketBufferSize() const { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; return actualUDPSocketBufferSize; } @@ -414,7 +414,7 @@ int64_t slsReceiverImplementation::getActualUDPSocketBufferSize() const { /**initial parameters***/ -void slsReceiverImplementation::setDetectorHostname(const std::string& c) { +void Implementation::setDetectorHostname(const std::string& c) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; if (!c.empty()) @@ -422,7 +422,7 @@ void slsReceiverImplementation::setDetectorHostname(const std::string& c) { FILE_LOG(logINFO) << "Detector Hostname: " << detHostname; } -void slsReceiverImplementation::setMultiDetectorSize(const int *size) { +void Implementation::setMultiDetectorSize(const int *size) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; std::string log_message = "Detector Size (ports): ("; for (int i = 0; i < MAX_DIMENSIONS; ++i) { @@ -452,7 +452,7 @@ void slsReceiverImplementation::setMultiDetectorSize(const int *size) { FILE_LOG(logINFO) << log_message; } -void slsReceiverImplementation::setFlippedDataX(int enable) { +void Implementation::setFlippedDataX(int enable) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; flippedDataX = (enable == 0) ? 0 : 1; @@ -471,7 +471,7 @@ void slsReceiverImplementation::setFlippedDataX(int enable) { FILE_LOG(logINFO) << "Flipped Data X: " << flippedDataX; } -int slsReceiverImplementation::setGapPixelsEnable(const bool b) { +int Implementation::setGapPixelsEnable(const bool b) { if (gapPixelsEnable != b) { gapPixelsEnable = b; @@ -487,7 +487,7 @@ int slsReceiverImplementation::setGapPixelsEnable(const bool b) { } -int slsReceiverImplementation::setQuad(const bool b) { +int Implementation::setQuad(const bool b) { if (quadEnable != b) { quadEnable = b; @@ -518,12 +518,12 @@ int slsReceiverImplementation::setQuad(const bool b) { return OK; } -void slsReceiverImplementation::setReadNLines(const int value) { +void Implementation::setReadNLines(const int value) { numLinesReadout = value; FILE_LOG(logINFO) << "Number of Lines to readout: " << numLinesReadout; } -int slsReceiverImplementation::setReadoutMode(const readoutMode f) { +int Implementation::setReadoutMode(const readoutMode f) { if (readoutType != f) { readoutType = f; @@ -543,7 +543,7 @@ int slsReceiverImplementation::setReadoutMode(const readoutMode f) { return OK; } -void slsReceiverImplementation::setFileFormat(const fileFormat f) { +void Implementation::setFileFormat(const fileFormat f) { switch (f) { #ifdef HDF5C case HDF5: @@ -561,7 +561,7 @@ void slsReceiverImplementation::setFileFormat(const fileFormat f) { FILE_LOG(logINFO) << "File Format: " << sls::ToString(fileFormatType); } -void slsReceiverImplementation::setFileName(const std::string& c) { +void Implementation::setFileName(const std::string& c) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; if (!c.empty()) @@ -569,7 +569,7 @@ void slsReceiverImplementation::setFileName(const std::string& c) { FILE_LOG(logINFO) << "File name: " << fileName; } -void slsReceiverImplementation::setFilePath(const std::string& c) { +void Implementation::setFilePath(const std::string& c) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; if (!c.empty()) { @@ -579,21 +579,21 @@ void slsReceiverImplementation::setFilePath(const std::string& c) { FILE_LOG(logINFO) << "File path: " << filePath; } -void slsReceiverImplementation::setFileIndex(const uint64_t i) { +void Implementation::setFileIndex(const uint64_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; fileIndex = i; FILE_LOG(logINFO) << "File Index: " << fileIndex; } -void slsReceiverImplementation::setFramesPerFile(const uint32_t i) { +void Implementation::setFramesPerFile(const uint32_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; framesPerFile = i; FILE_LOG(logINFO) << "Frames per file: " << framesPerFile; } -void slsReceiverImplementation::setFrameDiscardPolicy( +void Implementation::setFrameDiscardPolicy( const frameDiscardPolicy i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; @@ -604,14 +604,14 @@ void slsReceiverImplementation::setFrameDiscardPolicy( << sls::ToString(frameDiscardMode); } -void slsReceiverImplementation::setFramePaddingEnable(const bool i) { +void Implementation::setFramePaddingEnable(const bool i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; framePadding = i; FILE_LOG(logINFO) << "Frame Padding: " << framePadding; } -void slsReceiverImplementation::setFileWriteEnable(const bool b) { +void Implementation::setFileWriteEnable(const bool b) { if (fileWriteEnable != b) { fileWriteEnable = b; for (unsigned int i = 0; i < dataProcessor.size(); ++i) { @@ -625,14 +625,14 @@ void slsReceiverImplementation::setFileWriteEnable(const bool b) { FILE_LOG(logINFO) << "File Write Enable: " << (fileWriteEnable ? "enabled" : "disabled"); } -void slsReceiverImplementation::setMasterFileWriteEnable(const bool b) { +void Implementation::setMasterFileWriteEnable(const bool b) { masterFileWriteEnable = b; FILE_LOG(logINFO) << "Master File Write Enable: " << (masterFileWriteEnable ? "enabled" : "disabled"); } -void slsReceiverImplementation::setOverwriteEnable(const bool b) { +void Implementation::setOverwriteEnable(const bool b) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; overwriteEnable = b; @@ -640,35 +640,35 @@ void slsReceiverImplementation::setOverwriteEnable(const bool b) { } /***connection parameters***/ -void slsReceiverImplementation::setUDPPortNumber(const uint32_t i) { +void Implementation::setUDPPortNumber(const uint32_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; udpPortNum[0] = i; FILE_LOG(logINFO) << "UDP Port Number[0]: " << udpPortNum[0]; } -void slsReceiverImplementation::setUDPPortNumber2(const uint32_t i) { +void Implementation::setUDPPortNumber2(const uint32_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; udpPortNum[1] = i; FILE_LOG(logINFO) << "UDP Port Number[1]: " << udpPortNum[1]; } -void slsReceiverImplementation::setEthernetInterface(const std::string &c) { +void Implementation::setEthernetInterface(const std::string &c) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; eth[0] = c; FILE_LOG(logINFO) << "Ethernet Interface: " << eth[0]; } -void slsReceiverImplementation::setEthernetInterface2(const std::string &c) { +void Implementation::setEthernetInterface2(const std::string &c) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; eth[1] = c; FILE_LOG(logINFO) << "Ethernet Interface 2: " << eth[1]; } -int slsReceiverImplementation::setNumberofUDPInterfaces(const int n) { +int Implementation::setNumberofUDPInterfaces(const int n) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; if (numUDPInterfaces != n) { @@ -783,7 +783,7 @@ int slsReceiverImplementation::setNumberofUDPInterfaces(const int n) { return OK; } -int slsReceiverImplementation::setUDPSocketBufferSize(const int64_t s) { +int Implementation::setUDPSocketBufferSize(const int64_t s) { int64_t size = (s == 0) ? udpSocketBufferSize : s; size_t listSize = listener.size(); @@ -802,7 +802,7 @@ int slsReceiverImplementation::setUDPSocketBufferSize(const int64_t s) { } /***acquisition parameters***/ -int slsReceiverImplementation::setROI(slsDetectorDefs::ROI arg) { +int Implementation::setROI(slsDetectorDefs::ROI arg) { if (roi.xmin != arg.xmin || roi.xmax != arg.xmax) { roi.xmin = arg.xmin; roi.xmax = arg.xmax; @@ -822,7 +822,7 @@ int slsReceiverImplementation::setROI(slsDetectorDefs::ROI arg) { return OK; } -int slsReceiverImplementation::setADCEnableMask(uint32_t mask) { +int Implementation::setADCEnableMask(uint32_t mask) { if (adcEnableMask != mask) { adcEnableMask = mask; @@ -843,7 +843,7 @@ int slsReceiverImplementation::setADCEnableMask(uint32_t mask) { return OK; } -int slsReceiverImplementation::setStreamingFrequency(const uint32_t freq) { +int Implementation::setStreamingFrequency(const uint32_t freq) { if (streamingFrequency != freq) { streamingFrequency = freq; } @@ -851,14 +851,14 @@ int slsReceiverImplementation::setStreamingFrequency(const uint32_t freq) { return OK; } -void slsReceiverImplementation::setStreamingTimer(const uint32_t time_in_ms) { +void Implementation::setStreamingTimer(const uint32_t time_in_ms) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; streamingTimerInMs = time_in_ms; FILE_LOG(logINFO) << "Streamer Timer: " << streamingTimerInMs; } -int slsReceiverImplementation::setDataStreamEnable(const bool enable) { +int Implementation::setDataStreamEnable(const bool enable) { if (dataStreamEnable != enable) { dataStreamEnable = enable; @@ -895,25 +895,25 @@ int slsReceiverImplementation::setDataStreamEnable(const bool enable) { return OK; } -void slsReceiverImplementation::setStreamingPort(const uint32_t i) { +void Implementation::setStreamingPort(const uint32_t i) { streamingPort = i; FILE_LOG(logINFO) << "Streaming Port: " << streamingPort; } -void slsReceiverImplementation::setStreamingSourceIP(const sls::IpAddr ip) { +void Implementation::setStreamingSourceIP(const sls::IpAddr ip) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; streamingSrcIP = ip; FILE_LOG(logINFO) << "Streaming Source IP: " << streamingSrcIP; } -void slsReceiverImplementation::setAdditionalJsonHeader(const std::string& c) { +void Implementation::setAdditionalJsonHeader(const std::string& c) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; additionalJsonHeader = c; FILE_LOG(logINFO) << "Additional JSON Header: " << additionalJsonHeader; } -void slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i) { +void Implementation::setAcquisitionPeriod(const uint64_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; acquisitionPeriod = i; @@ -921,7 +921,7 @@ void slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i) { << (double)acquisitionPeriod / (1E9) << "s"; } -void slsReceiverImplementation::setAcquisitionTime(const uint64_t i) { +void Implementation::setAcquisitionTime(const uint64_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; acquisitionTime = i; @@ -929,7 +929,7 @@ void slsReceiverImplementation::setAcquisitionTime(const uint64_t i) { << "s"; } -void slsReceiverImplementation::setSubExpTime(const uint64_t i) { +void Implementation::setSubExpTime(const uint64_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; subExpTime = i; @@ -937,7 +937,7 @@ void slsReceiverImplementation::setSubExpTime(const uint64_t i) { << "s"; } -void slsReceiverImplementation::setSubPeriod(const uint64_t i) { +void Implementation::setSubPeriod(const uint64_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; subPeriod = i; @@ -945,14 +945,14 @@ void slsReceiverImplementation::setSubPeriod(const uint64_t i) { << "s"; } -void slsReceiverImplementation::setNumberOfFrames(const uint64_t i) { +void Implementation::setNumberOfFrames(const uint64_t i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; numberOfFrames = i; FILE_LOG(logINFO) << "Number of Frames: " << numberOfFrames; } -int slsReceiverImplementation::setNumberofAnalogSamples(const uint32_t i) { +int Implementation::setNumberofAnalogSamples(const uint32_t i) { if (numberOfAnalogSamples != i) { numberOfAnalogSamples = i; @@ -971,7 +971,7 @@ int slsReceiverImplementation::setNumberofAnalogSamples(const uint32_t i) { return OK; } -int slsReceiverImplementation::setNumberofDigitalSamples(const uint32_t i) { +int Implementation::setNumberofDigitalSamples(const uint32_t i) { if (numberOfDigitalSamples != i) { numberOfDigitalSamples = i; @@ -991,7 +991,7 @@ int slsReceiverImplementation::setNumberofDigitalSamples(const uint32_t i) { return OK; } -int slsReceiverImplementation::setDynamicRange(const uint32_t i) { +int Implementation::setDynamicRange(const uint32_t i) { // only eiger if (dynamicRange != i) { dynamicRange = i; @@ -1007,7 +1007,7 @@ int slsReceiverImplementation::setDynamicRange(const uint32_t i) { return OK; } -int slsReceiverImplementation::setTenGigaEnable(const bool b) { +int Implementation::setTenGigaEnable(const bool b) { if (tengigaEnable != b) { tengigaEnable = b; // side effects @@ -1035,7 +1035,7 @@ int slsReceiverImplementation::setTenGigaEnable(const bool b) { return OK; } -int slsReceiverImplementation::setFifoDepth(const uint32_t i) { +int Implementation::setFifoDepth(const uint32_t i) { if (fifoDepth != i) { fifoDepth = i; if (SetupFifoStructure() == FAIL) @@ -1046,14 +1046,14 @@ int slsReceiverImplementation::setFifoDepth(const uint32_t i) { } /***receiver parameters***/ -bool slsReceiverImplementation::setActivate(bool enable) { +bool Implementation::setActivate(bool enable) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; activated = enable; FILE_LOG(logINFO) << "Activation: " << (activated ? "enabled" : "disabled"); return activated; } -bool slsReceiverImplementation::setDeactivatedPadding(bool enable) { +bool Implementation::setDeactivatedPadding(bool enable) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; deactivatedPaddingEnable = enable; FILE_LOG(logINFO) << "Deactivated Padding Enable: " @@ -1061,19 +1061,19 @@ bool slsReceiverImplementation::setDeactivatedPadding(bool enable) { return deactivatedPaddingEnable; } -void slsReceiverImplementation::setSilentMode(const bool i) { +void Implementation::setSilentMode(const bool i) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; silentMode = i; FILE_LOG(logINFO) << "Silent Mode: " << i; } -void slsReceiverImplementation::setDbitList(const std::vector v) { +void Implementation::setDbitList(const std::vector v) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; ctbDbitList = v; } -void slsReceiverImplementation::setDbitOffset(const int s) { +void Implementation::setDbitOffset(const int s) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; ctbDbitOffset = s; } @@ -1084,7 +1084,7 @@ void slsReceiverImplementation::setDbitOffset(const int s) { *************************************************************************/ /***initial functions***/ -int slsReceiverImplementation::setDetectorType(const detectorType d) { +int Implementation::setDetectorType(const detectorType d) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; DeleteMembers(); InitializeMembers(); @@ -1177,7 +1177,7 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) { return OK; } -void slsReceiverImplementation::setDetectorPositionId(const int id) { +void Implementation::setDetectorPositionId(const int id) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; detID = id; FILE_LOG(logINFO) << "Detector Position Id:" << detID; @@ -1198,7 +1198,7 @@ void slsReceiverImplementation::setDetectorPositionId(const int id) { } -int slsReceiverImplementation::startReceiver(std::string& err) { +int Implementation::startReceiver(std::string& err) { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; FILE_LOG(logINFO) << "Starting Receiver"; ResetParametersforNewAcquisition(); @@ -1244,7 +1244,7 @@ int slsReceiverImplementation::startReceiver(std::string& err) { return OK; } -void slsReceiverImplementation::stopReceiver() { +void Implementation::stopReceiver() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; FILE_LOG(logINFO) << "Stopping Receiver"; @@ -1336,7 +1336,7 @@ void slsReceiverImplementation::stopReceiver() { FILE_LOG(logINFO) << "Status: " << sls::ToString(status); } -void slsReceiverImplementation::startReadout() { +void Implementation::startReadout() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; if (status == RUNNING) { // wait for incoming delayed packets @@ -1372,13 +1372,13 @@ void slsReceiverImplementation::startReadout() { shutDownUDPSockets(); } -void slsReceiverImplementation::shutDownUDPSockets() { +void Implementation::shutDownUDPSockets() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; for (const auto &it : listener) it->ShutDownUDPSocket(); } -void slsReceiverImplementation::closeFiles() { +void Implementation::closeFiles() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; uint64_t maxIndexCaught = 0; bool anycaught = false; @@ -1394,7 +1394,7 @@ void slsReceiverImplementation::closeFiles() { dataProcessor[0]->EndofAcquisition(anycaught, maxIndexCaught); } -int slsReceiverImplementation::restreamStop() { +int Implementation::restreamStop() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; for (const auto &it : dataStreamer) { if (it->RestreamStop() == FAIL) @@ -1405,19 +1405,19 @@ int slsReceiverImplementation::restreamStop() { } /***callback functions***/ -void slsReceiverImplementation::registerCallBackStartAcquisition( +void Implementation::registerCallBackStartAcquisition( int (*func)(std::string, std::string, uint64_t, uint32_t, void *), void *arg) { startAcquisitionCallBack = func; pStartAcquisition = arg; } -void slsReceiverImplementation::registerCallBackAcquisitionFinished( +void Implementation::registerCallBackAcquisitionFinished( void (*func)(uint64_t, void *), void *arg) { acquisitionFinishedCallBack = func; pAcquisitionFinished = arg; } -void slsReceiverImplementation::registerCallBackRawDataReady( +void Implementation::registerCallBackRawDataReady( void (*func)(char *, char *, uint32_t, void *), void *arg) { rawDataReadyCallBack = func; pRawDataReady = arg; @@ -1425,7 +1425,7 @@ void slsReceiverImplementation::registerCallBackRawDataReady( it->registerCallBackRawDataReady(rawDataReadyCallBack, pRawDataReady); } -void slsReceiverImplementation::registerCallBackRawDataModifyReady( +void Implementation::registerCallBackRawDataModifyReady( void (*func)(char *, char *, uint32_t &, void *), void *arg) { rawDataModifyReadyCallBack = func; pRawDataReady = arg; @@ -1434,7 +1434,7 @@ void slsReceiverImplementation::registerCallBackRawDataModifyReady( pRawDataReady); } -void slsReceiverImplementation::SetLocalNetworkParameters() { +void Implementation::SetLocalNetworkParameters() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; // to increase Max length of input packet queue @@ -1462,7 +1462,7 @@ void slsReceiverImplementation::SetLocalNetworkParameters() { } } -void slsReceiverImplementation::SetThreadPriorities() { +void Implementation::SetThreadPriorities() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; for (const auto &it : listener) { @@ -1480,7 +1480,7 @@ void slsReceiverImplementation::SetThreadPriorities() { FILE_LOG(logINFO) << osfn.str(); } -int slsReceiverImplementation::SetupFifoStructure() { +int Implementation::SetupFifoStructure() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; fifo.clear(); @@ -1517,7 +1517,7 @@ int slsReceiverImplementation::SetupFifoStructure() { return OK; } -void slsReceiverImplementation::ResetParametersforNewAcquisition() { +void Implementation::ResetParametersforNewAcquisition() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; for (const auto &it : listener) @@ -1534,7 +1534,7 @@ void slsReceiverImplementation::ResetParametersforNewAcquisition() { } } -int slsReceiverImplementation::CreateUDPSockets() { +int Implementation::CreateUDPSockets() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; bool error = false; @@ -1554,7 +1554,7 @@ int slsReceiverImplementation::CreateUDPSockets() { return OK; } -int slsReceiverImplementation::SetupWriter() { +int Implementation::SetupWriter() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; bool error = false; masterAttributes attr; @@ -1596,7 +1596,7 @@ int slsReceiverImplementation::SetupWriter() { return OK; } -void slsReceiverImplementation::StartRunning() { +void Implementation::StartRunning() { FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called"; // set running mask and post semaphore to start the inner loop in execution // thread diff --git a/slsReceiverSoftware/src/Receiver.cpp b/slsReceiverSoftware/src/Receiver.cpp index a40aedccc..965184f3a 100755 --- a/slsReceiverSoftware/src/Receiver.cpp +++ b/slsReceiverSoftware/src/Receiver.cpp @@ -1,5 +1,4 @@ #include "Receiver.h" -#include "slsReceiverTCPIPInterface.h" #include "sls_detector_exceptions.h" #include "versionAPI.h" #include "container_utils.h" @@ -71,14 +70,14 @@ Receiver::Receiver(int argc, char *argv[]): } // might throw an exception - tcpipInterface = sls::make_unique(tcpip_port_no); + tcpipInterface = sls::make_unique(tcpip_port_no); } Receiver::Receiver(int tcpip_port_no) { // might throw an exception - tcpipInterface = sls::make_unique(tcpip_port_no); + tcpipInterface = sls::make_unique(tcpip_port_no); } int64_t Receiver::getReceiverVersion(){