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

receiver tcp interface updated

Browse Source
This commit is contained in:
maliakal_d 2018-10-12 17:03:19 +02:00
parent c31c851e88
commit 8382d0f5f9
7 changed files with 990 additions and 1046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.cpp
View File

@ -1033,7 +1033,7 @@ int multiSlsDetector::writeConfigurationFile(const std::string& fname) {
}
int ret = OK, ret1 = OK;
std::ofstream outfile;
int iline = 0;
size_t iline = 0;
outfile.open(fname.c_str(), std::ios_base::out);
if (outfile.is_open()) {

19
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@ -106,27 +106,12 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
*/
void startTCPServer();
/** retuns function name with function index */
const char* getFunctionName(enum detFuncs func);
/** assigns functions to the fnum enum */
int function_table();
/** Decodes Function */
int decode_function();
/** print socket read error */
int printSocketReadError();
/** receiver object is null */
void invalidReceiverObject();
/** receiver already locked */
void receiverlocked();
/** receiver not idle */
void receiverNotIdle();
/** function not implemented for specific detector */
void functionNotImplemented();
@ -287,7 +272,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
detectorType myDetectorType;
/** slsReceiverBase object */
slsReceiverImplementation *receiverBase;
slsReceiverImplementation *receiver;
/** Function List */
int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])();
@ -371,5 +356,5 @@ protected:
MySocketTCP* mySock;
/** client interface */
ClientInterface* clientInterface;
ClientInterface* interface;
};

6
slsReceiverSoftware/src/slsReceiverImplementation.cpp
View File

@ -372,11 +372,13 @@ uint32_t slsReceiverImplementation::getFifoDepth() const{
/***receiver status***/
slsDetectorDefs::runStatus slsReceiverImplementation::getStatus() const{
FILE_LOG(logDEBUG) << __AT__ << " starting";
return status;}
return status;
}
bool slsReceiverImplementation::getSilentMode() const{
FILE_LOG(logDEBUG) << __AT__ << " starting";
return silentMode;}
return silentMode;
}
bool slsReceiverImplementation::getActivate() const{
FILE_LOG(logDEBUG) << __AT__ << " starting";

1678
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

File diff suppressed because it is too large Load Diff

126
slsSupportLib/include/ClientInterface.cpp
View File

@ -20,50 +20,25 @@ ClientInterface::~ClientInterface(){}
void ClientInterface::SetSocket(MySocketTCP *socket) {
mySocket=socket;
}
int ClientInterface::PrintSocketReadError() {
FILE_LOG(logERROR) << "Reading from socket failed. Possible socket crash";
return FAIL;
}
void ClientInterface::Server_SendResult(bool diffClients, int ret,
void* retval, int retvalSize, char* mess) {
// update if different clients
if (diffClients)
ret = FORCE_UPDATE;
// send success of operation
mySocket->SendDataOnly(&ret,sizeof(ret));
if(ret == FAIL) {
// send error message
if (mess)
mySocket->SendDataOnly(mess, MAX_STR_LENGTH);
// debugging feature. should not happen.
else
FILE_LOG(logERROR) << "No error message provided for this failure. Will mess up TCP\n";
}
// send return value
mySocket->SendDataOnly(retval, retvalSize);
mySocket = socket;
}
int ClientInterface::Client_GetMesage(char* mess) {
bool created = false;
int ret = OK;
if (!mess){
char messref[MAX_STR_LENGTH];
memset(messref, 0, MAX_STR_LENGTH);
mess = (char*)messref;
created = true;
mess = new char[MAX_STR_LENGTH];
memset(mess, 0, MAX_STR_LENGTH);
}
mySocket->ReceiveDataOnly(mess,MAX_STR_LENGTH);
cprintf(RED, "%s %d returned error: %s", type.c_str(), index, mess);
if(strstr(mess,"Unrecognized Function")!=NULL)
ret = FAIL;
if (created)
delete [] mess;
return ret;
}
@ -110,6 +85,93 @@ int ClientInterface::Client_Send(int fnum,
}
void ClientInterface::Server_SendResult(bool update, int ret,
void* retval, int retvalSize, char* mess) {
// update if different clients
if (update && mySocket->differentClients)
ret = FORCE_UPDATE;
// send success of operation
mySocket->SendDataOnly(&ret,sizeof(ret));
if(ret == FAIL) {
// send error message
if (mess)
mySocket->SendDataOnly(mess, MAX_STR_LENGTH);
// debugging feature. should not happen.
else
FILE_LOG(logERROR) << "No error message provided for this failure. Will mess up TCP\n";
}
// send return value
mySocket->SendDataOnly(retval, retvalSize);
}
int ClientInterface::Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg, bool checkbase, void* base) {
// client socket crash, cannot receive arguments
if (sizeofArg && mySocket->ReceiveDataOnly(arg, sizeofArg) < 0)
return Server_SocketCrash();
ret = OK;
// check if server object created
if (checkbase && base == NULL)
Server_NullObjectError(ret, mess);
// no crash
return OK;
}
int ClientInterface::Server_VerifyLock(int& ret, char* mess, int lockstatus) {
// server locked
if (mySocket->differentClients && lockstatus)
return Server_LockedError(ret, mess);
return ret;
}
int ClientInterface::Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum) {
// server locked
if (mySocket->differentClients && lockstatus)
return Server_LockedError(ret, mess);
// server not idle for this command
if (status != slsDetectorDefs::IDLE)
return Server_NotIdleError(ret, mess, fnum);
return ret;
}
void ClientInterface::Server_NullObjectError(int& ret, char* mess) {
// only for receiver
ret=FAIL;
strcpy(mess,"Receiver not set up. Please use rx_hostname first.\n");
FILE_LOG(logERROR) << mess;
}
int ClientInterface::Server_SocketCrash() {
FILE_LOG(logERROR) << "Reading from socket failed. Possible socket crash";
return FAIL;
}
int ClientInterface::Server_LockedError(int& ret, char* mess) {
ret = FAIL;
sprintf(mess,"%s locked by %s\n",type.c_str(), mySocket->lastClientIP);
FILE_LOG(logERROR) << mess;
return ret;
}
int ClientInterface::Server_NotIdleError(int& ret, char* mess, int fnum) {
ret = FAIL;
sprintf(mess,"Can not execute %s when %s is not idle\n",
getFunctionNameFromEnum((enum detFuncs)fnum), type.c_str());
FILE_LOG(logERROR) << mess;
return ret;
}

87
slsSupportLib/include/ClientInterface.h
View File

@ -33,21 +33,6 @@ public:
*/
void SetSocket(MySocketTCP *socket);
/**
* Print socket read error in Server
*/
int PrintSocketReadError();
/**
* Server sends result to client (also set ret to force_update if different clients)
* @param diffClients true if different clients, else false
* @param ret success of operation
* @param retval pointer to result
* @param retvalSize size of result
* @param mess message
*/
void Server_SendResult(bool diffClients, int ret, void* retval, int retvalSize, char* mess = 0);
/**
* Get message from server
* Print appropriate message
@ -89,6 +74,78 @@ public:
void* retval, int sizeOfRetval,
char* mess = 0);
/**
* Server sends result to client (also set ret to force_update if different clients)
* @param update true if one must update if different clients, else false
* @param ret success of operation
* @param retval pointer to result
* @param retvalSize size of result
* @param mess message
*/
void Server_SendResult(bool update, int ret, void* retval, int retvalSize, char* mess = 0);
/**
* Server receives arguments and checks if base object is null (if checkbase is true)
* checking base object is null (for reciever only when it has not been configured yet)
* @param ret pointer to success of operation
* @param mess message
* @param arg pointer to argument
* @param sizeofArg size of argument
* @param checkbase if true, checks if base object is null and sets ret and mess accordingly
* @param base pointer to base object
* @returns fail if socket crashes while reading arguments, else fail
*/
int Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg,bool checkbase=false, void* base=NULL);
/**
* Server verifies if it is locked, sets and prints appropriate message if it is
* @param ret pointer to sucess
* @param mess message
* @param lockstatus status of lock
* @returns success of operaton
*/
int Server_VerifyLock(int& ret, char* mess, int lockstatus);
/**
* Server verifies if it is locked and idle, sets and prints appropriate message if it is
* @param ret pointer to sucess
* @param mess message
* @param lockstatus status of lock
* @param staus status of server
* @param fnum function number for error message
* @returns success of operaton
*/
int Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum);
/**
* Server sets and prints error message for null object error (receiver only)
* @param ret pointer to sucess that will be set to FAIL
* @param mess message
*/
void Server_NullObjectError(int& ret, char* mess);
/**
* Servers prints error message for socket crash when reading
* @returns always FAIL
*/
int Server_SocketCrash();
/**
* Servers sets and prints error message for locked server
* @param ret pointer to sucess that will be set to FAIL
* @param mess message
* @returns success of operaton
*/
int Server_LockedError(int& ret, char* mess);
/**
* Servers sets and prints error message for server not being idle
* @param ret pointer to sucess that will be set to FAIL
* @param mess message
* @param fnum function number for error message
* @returns success of operaton
*/
int Server_NotIdleError(int& ret, char* mess, int fnum);
private:

118
slsSupportLib/include/sls_detector_funcs.h
View File

@ -121,3 +121,121 @@ enum detFuncs{
NUM_REC_FUNCTIONS
};
static const char* getFunctionNameFromEnum(enum detFuncs func) {
switch (func) {
case F_EXEC_COMMAND: return "F_EXEC_COMMAND";
case F_GET_DETECTOR_TYPE: return "F_GET_DETECTOR_TYPE";
case F_SET_EXTERNAL_SIGNAL_FLAG: return "F_SET_EXTERNAL_SIGNAL_FLAG";
case F_SET_EXTERNAL_COMMUNICATION_MODE: return "F_SET_EXTERNAL_COMMUNICATION_MODE";
case F_GET_ID: return "F_GET_ID";
case F_DIGITAL_TEST: return "F_DIGITAL_TEST";
case F_SET_DAC: return "F_SET_DAC";
case F_GET_ADC: return "F_GET_ADC";
case F_WRITE_REGISTER: return "F_WRITE_REGISTER";
case F_READ_REGISTER: return "F_READ_REGISTER";
case F_SET_MODULE: return "F_SET_MODULE";
case F_GET_MODULE: return "F_GET_MODULE";
case F_SET_SETTINGS: return "F_SET_SETTINGS";
case F_GET_THRESHOLD_ENERGY: return "F_GET_THRESHOLD_ENERGY";
case F_START_ACQUISITION: return "F_START_ACQUISITION";
case F_STOP_ACQUISITION: return "F_STOP_ACQUISITION";
case F_START_READOUT: return "F_START_READOUT";
case F_GET_RUN_STATUS: return "F_GET_RUN_STATUS";
case F_START_AND_READ_ALL: return "F_START_AND_READ_ALL";
case F_READ_ALL: return "F_READ_ALL";
case F_SET_TIMER: return "F_SET_TIMER";
case F_GET_TIME_LEFT: return "F_GET_TIME_LEFT";
case F_SET_DYNAMIC_RANGE: return "F_SET_DYNAMIC_RANGE";
case F_SET_READOUT_FLAGS: return "F_SET_READOUT_FLAGS";
case F_SET_ROI: return "F_SET_ROI";
case F_SET_SPEED: return "F_SET_SPEED";
case F_EXIT_SERVER: return "F_EXIT_SERVER";
case F_LOCK_SERVER: return "F_LOCK_SERVER";
case F_GET_LAST_CLIENT_IP: return "F_GET_LAST_CLIENT_IP";
case F_SET_PORT: return "F_SET_PORT";
case F_UPDATE_CLIENT: return "F_UPDATE_CLIENT";
case F_CONFIGURE_MAC: return "F_CONFIGURE_MAC";
case F_LOAD_IMAGE: return "F_LOAD_IMAGE";
case F_READ_COUNTER_BLOCK: return "F_READ_COUNTER_BLOCK";
case F_RESET_COUNTER_BLOCK: return "F_RESET_COUNTER_BLOCK";
case F_CALIBRATE_PEDESTAL: return "F_CALIBRATE_PEDESTAL";
case F_ENABLE_TEN_GIGA: return "F_ENABLE_TEN_GIGA";
case F_SET_ALL_TRIMBITS: return "F_SET_ALL_TRIMBITS";
case F_SET_CTB_PATTERN: return "F_SET_CTB_PATTERN";
case F_WRITE_ADC_REG: return "F_WRITE_ADC_REG";
case F_SET_COUNTER_BIT: return "F_SET_COUNTER_BIT";
case F_PULSE_PIXEL: return "F_PULSE_PIXEL";
case F_PULSE_PIXEL_AND_MOVE: return "F_PULSE_PIXEL_AND_MOVE";
case F_PULSE_CHIP: return "F_PULSE_CHIP";
case F_SET_RATE_CORRECT: return "F_SET_RATE_CORRECT";
case F_GET_RATE_CORRECT: return "F_GET_RATE_CORRECT";
case F_SET_NETWORK_PARAMETER: return "F_SET_NETWORK_PARAMETER";
case F_PROGRAM_FPGA: return "F_PROGRAM_FPGA";
case F_RESET_FPGA: return "F_RESET_FPGA";
case F_POWER_CHIP: return "F_POWER_CHIP";
case F_ACTIVATE: return "F_ACTIVATE";
case F_PREPARE_ACQUISITION: return "F_PREPARE_ACQUISITION";
case F_THRESHOLD_TEMP: return "F_THRESHOLD_TEMP";
case F_TEMP_CONTROL: return "F_TEMP_CONTROL";
case F_TEMP_EVENT: return "F_TEMP_EVENT";
case F_AUTO_COMP_DISABLE: return "F_AUTO_COMP_DISABLE";
case F_STORAGE_CELL_START: return "F_STORAGE_CELL_START";
case F_CHECK_VERSION: return "F_CHECK_VERSION";
case F_SOFTWARE_TRIGGER: return "F_SOFTWARE_TRIGGER";
case NUM_DET_FUNCTIONS: return "NUM_DET_FUNCTIONS";
case RECEIVER_ENUM_START: return "RECEIVER_ENUM_START";
case F_EXEC_RECEIVER_COMMAND: return "F_EXEC_RECEIVER_COMMAND";
case F_EXIT_RECEIVER: return "F_EXIT_RECEIVER";
case F_LOCK_RECEIVER: return "F_LOCK_RECEIVER";
case F_GET_LAST_RECEIVER_CLIENT_IP: return "F_GET_LAST_RECEIVER_CLIENT_IP";
case F_SET_RECEIVER_PORT: return "F_SET_RECEIVER_PORT";
case F_UPDATE_RECEIVER_CLIENT: return "F_UPDATE_RECEIVER_CLIENT";
case F_GET_RECEIVER_ID: return "F_GET_RECEIVER_ID";
case F_GET_RECEIVER_TYPE: return "F_GET_RECEIVER_TYPE";
case F_SEND_RECEIVER_DETHOSTNAME: return "F_SEND_RECEIVER_DETHOSTNAME";
case F_RECEIVER_SET_ROI: return "F_RECEIVER_SET_ROI";
case F_SETUP_RECEIVER_UDP: return "F_SETUP_RECEIVER_UDP";
case F_SET_RECEIVER_TIMER: return "F_SET_RECEIVER_TIMER";
case F_SET_RECEIVER_DYNAMIC_RANGE: return "F_SET_RECEIVER_DYNAMIC_RANGE";
case F_RECEIVER_STREAMING_FREQUENCY: return "F_RECEIVER_STREAMING_FREQUENCY";
case F_GET_RECEIVER_STATUS: return "F_GET_RECEIVER_STATUS";
case F_START_RECEIVER: return "F_START_RECEIVER";
case F_STOP_RECEIVER: return "F_STOP_RECEIVER";
case F_SET_RECEIVER_FILE_PATH: return "F_SET_RECEIVER_FILE_PATH";
case F_SET_RECEIVER_FILE_NAME: return "F_SET_RECEIVER_FILE_NAME";
case F_SET_RECEIVER_FILE_INDEX: return "F_SET_RECEIVER_FILE_INDEX";
case F_GET_RECEIVER_FRAME_INDEX: return "F_GET_RECEIVER_FRAME_INDEX";
case F_GET_RECEIVER_FRAMES_CAUGHT: return "F_GET_RECEIVER_FRAMES_CAUGHT";
case F_RESET_RECEIVER_FRAMES_CAUGHT: return "F_RESET_RECEIVER_FRAMES_CAUGHT";
case F_ENABLE_RECEIVER_FILE_WRITE: return "F_ENABLE_RECEIVER_FILE_WRITE";
case F_ENABLE_RECEIVER_OVERWRITE: return "F_ENABLE_RECEIVER_OVERWRITE";
case F_ENABLE_RECEIVER_TEN_GIGA: return "F_ENABLE_RECEIVER_TEN_GIGA";
case F_SET_RECEIVER_FIFO_DEPTH: return "F_SET_RECEIVER_FIFO_DEPTH";
case F_RECEIVER_ACTIVATE: return "F_RECEIVER_ACTIVATE";
case F_STREAM_DATA_FROM_RECEIVER: return "F_STREAM_DATA_FROM_RECEIVER";
case F_RECEIVER_STREAMING_TIMER: return "F_RECEIVER_STREAMING_TIMER";
case F_SET_FLIPPED_DATA_RECEIVER: return "F_SET_FLIPPED_DATA_RECEIVER";
case F_SET_RECEIVER_FILE_FORMAT: return "F_SET_RECEIVER_FILE_FORMAT";
case F_SEND_RECEIVER_DETPOSID: return "F_SEND_RECEIVER_DETPOSID";
case F_SEND_RECEIVER_MULTIDETSIZE: return "F_SEND_RECEIVER_MULTIDETSIZE";
case F_SET_RECEIVER_STREAMING_PORT: return "F_SET_RECEIVER_STREAMING_PORT";
case F_RECEIVER_STREAMING_SRC_IP: return "F_RECEIVER_STREAMING_SRC_IP";
case F_SET_RECEIVER_SILENT_MODE: return "F_SET_RECEIVER_SILENT_MODE";
case F_ENABLE_GAPPIXELS_IN_RECEIVER: return "F_ENABLE_GAPPIXELS_IN_RECEIVER";
case F_RESTREAM_STOP_FROM_RECEIVER: return "F_RESTREAM_STOP_FROM_RECEIVER";
case F_ADDITIONAL_JSON_HEADER: return "F_ADDITIONAL_JSON_HEADER";
case F_RECEIVER_UDP_SOCK_BUF_SIZE: return "F_RECEIVER_UDP_SOCK_BUF_SIZE";
case F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE: return "F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE";
case F_SET_RECEIVER_FRAMES_PER_FILE: return "F_SET_RECEIVER_FRAMES_PER_FILE";
case F_RECEIVER_CHECK_VERSION: return "F_RECEIVER_CHECK_VERSION";
case F_RECEIVER_DISCARD_POLICY: return "F_RECEIVER_DISCARD_POLICY";
case F_RECEIVER_PADDING_ENABLE: return "F_RECEIVER_PADDING_ENABLE";
case F_RECEIVER_DEACTIVATED_PADDING_ENABLE: return "F_RECEIVER_DEACTIVATED_PADDING_ENABLE";
case NUM_REC_FUNCTIONS: return "NUM_REC_FUNCTIONS";
default: return "Unknown Function";
}
}