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

rxr: renamed files, removed unnecessary comments

Browse Source
This commit is contained in:
maliakal_d 2019-11-18 16:19:46 +01:00
parent 5ce79ec9fa
commit c4e7086d99
8 changed files with 607 additions and 1587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
slsReceiverSoftware/CMakeLists.txt
View File

@ -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

292
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h → slsReceiverSoftware/include/ClientInterface.h
View File

@ -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 <typename T>
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<slsReceiverImplementation> receiver{nullptr};
/** Function List */
int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(
std::unique_ptr<Implementation> 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 {

310
slsReceiverSoftware/include/Implementation.h Executable file
View File

@ -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 <atomic>
#include <exception>
#include <memory>
#include <vector>
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<int> 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<int> 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<runStatus> status;
bool activated;
bool deactivatedPaddingEnable;
frameDiscardPolicy frameDiscardMode;
bool framePadding;
bool silentMode;
std::vector<int> ctbDbitList;
int ctbDbitOffset;
int ctbAnalogDataBytes;
//***connection parameters***
int numUDPInterfaces;
std::vector <std::string> 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<std::unique_ptr<Listener>> listener;
std::vector<std::unique_ptr<DataProcessor>> dataProcessor;
std::vector<std::unique_ptr<DataStreamer>> dataStreamer;
std::vector<std::unique_ptr<Fifo>> 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;
};

4
slsReceiverSoftware/include/Receiver.h
View File

@ -1,5 +1,5 @@
#pragma once
#include "slsReceiverTCPIPInterface.h"
#include "ClientInterface.h"
#include "sls_detector_defs.h"
#include <memory>
@ -76,5 +76,5 @@ class Receiver : private virtual slsDetectorDefs {
private:
std::unique_ptr<slsReceiverTCPIPInterface> tcpipInterface;
std::unique_ptr<ClientInterface> tcpipInterface;
};

1021
slsReceiverSoftware/include/slsReceiverImplementation.h
View File

File diff suppressed because it is too large Load Diff

316
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp → slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -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 <typename T>
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<int>();
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<int>();
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<detectorType>();
// set
if (arg >= 0) {
@ -479,7 +471,7 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) {
}
if (receiver == nullptr) {
receiver = sls::make_unique<slsReceiverImplementation>();
receiver = sls::make_unique<Implementation>();
}
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<int64_t>();
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<int>();
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<int>();
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<int64_t>();
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<int64_t>();
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<int64_t>();
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<int64_t>();
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<int>();
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<int>();
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<int64_t>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int>();
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<int64_t>();
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<int>();
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<int64_t>();
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<int>();
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<int>();
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<int>();
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<readoutMode>();
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<uint32_t>();
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<int, MAX_RX_DBIT> 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<int, MAX_RX_DBIT> 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<int>();
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<int>();
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<int>();
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<sls::IpAddr>();
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<sls::IpAddr>();
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<int>();
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<int>();
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<int>();
arg = (arg > 1 ? 2 : 1);
VerifyIdle(socket);

242
slsReceiverSoftware/src/slsReceiverImplementation.cpp → slsReceiverSoftware/src/Implementation.cpp
View File

@ -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<int> slsReceiverImplementation::getDbitList() const {
std::vector<int> 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<int> v) {
void Implementation::setDbitList(const std::vector<int> 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

5
slsReceiverSoftware/src/Receiver.cpp
View File

@ -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<slsReceiverTCPIPInterface>(tcpip_port_no);
tcpipInterface = sls::make_unique<ClientInterface>(tcpip_port_no);
}
Receiver::Receiver(int tcpip_port_no)
{
// might throw an exception
tcpipInterface = sls::make_unique<slsReceiverTCPIPInterface>(tcpip_port_no);
tcpipInterface = sls::make_unique<ClientInterface>(tcpip_port_no);
}
int64_t Receiver::getReceiverVersion(){