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

Merge branch 'developer' into gui

Browse Source
This commit is contained in:
maliakal_d
2019-06-25 09:08:29 +02:00
parent 33f5253831 4b69c01357
commit 3db09bc0cd
11 changed files with 71 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
slsSupportLib/include/CmdProxy.h
View File

@ -1,5 +1,6 @@
#pragma once
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
@ -7,7 +8,9 @@
#include <vector>
#include "logger.h"
#include "slsDetectorCommand.h"
#include "sls_detector_exceptions.h"
#include "string_utils.h"
namespace sls {
@ -58,7 +61,7 @@ template <typename T> class CmdProxy {
using StringMap = std::map<std::string, std::string>;
// Initialize maps for translating name and function
FunctionMap functions{{"newfunc", &CmdProxy::NewFunction}};
FunctionMap functions{{"list", &CmdProxy::ListCommands}};
StringMap depreciated_functions{{"r_readfreq", "rx_readfreq"},
{"r_padding", "rx_padding"},
@ -80,34 +83,43 @@ template <typename T> class CmdProxy {
{"fileformat", "fformat"},
{"overwrite", "foverwrite"}};
template <typename U> std::string ResultToString(const U &ret) {
std::ostringstream os;
if (det_id != -1)
os << det_id << ":";
os << cmd << " " << ret << "\n";
return os.str();
}
void WrongNumberOfParameters(size_t expected) {
throw RuntimeError("ERROR: Expected " + std::to_string(expected) +
" parameters but got " +
std::to_string(args.size()) + "\n");
throw RuntimeError(
"Command " + cmd + " expected <=" + std::to_string(expected) +
" parameter/s but got " + std::to_string(args.size()) + "\n");
}
// Mapped functions
// example
std::string NewFunction() {
std::string ListCommands() {
if (args.size() == 0) {
std::cout << "This is the new function function\n";
return ResultToString(det->setExposureTime(-1, true));
auto commands = slsDetectorCommand(nullptr).getAllCommands();
for (const auto &it : functions)
commands.emplace_back(it.first);
std::sort(begin(commands), end(commands));
std::cout << "These " << commands.size()
<< " commands are available\n";
for (auto &c : commands)
std::cout << c << '\n';
return "";
} else if (args.size() == 1) {
std::cout << "Setting exposure time to " << args[0] << "s\n";
return ResultToString(
det->setExposureTime(std::stod(args[0]), true, det_id));
if (args[0] == "deprecated") {
std::cout << "The following " << depreciated_functions.size()
<< " commands are deprecated\n";
size_t field_width = 20;
for (const auto &it : depreciated_functions) {
std::cout << std::right << std::setw(field_width)
<< it.first << " -> " << it.second << '\n';
}
return "";
} else {
throw RuntimeError(
"Could not decode argument. Possible options: deprecated");
}
} else {
WrongNumberOfParameters(1);
return {};
return "";
}
}
};

42
slsSupportLib/include/MySocketTCP.h
View File

@ -1,42 +0,0 @@
#pragma once
/**
*
* @libdoc The MySocketTCP class provides a simple interface for creating and sending/receiving data over a TCP socket.
*
* @short This class provides a simple interface for creating and sending/receiving data over a TCP socket.
* @author Ian Johnson
* @version 1.0
*/
//version 1.0, base development, Ian 19/01/09
/* Modified by anna on 19.01.2009 */
/*
canceled SetupParameters() and varaibles intialized in the constructors' headers;
defined SEND_REC_MAX_SIZE (for compatibilty with mythen (and possibly other) pure C servers (i would move it to the common header file)
added #ifndef C_ONLY... to cutout class definition when including in pure C servers (can be removed if SEND_REC_MAX_SIZE is moved to the common header file)
defined private variables char hostname[1000] and int portno to store connection informations;
defined public functions int getHostname(char *name) and int getPortNumber() to retrieve connection informations
added public function int getErrorStatus() returning 1 if socketDescriptor<0
remove exits in the constructors and replace them with socketDescriptor=-1
replaced the argument of send/receive data with void (to avoid too much casting or compiler errors/warnings)
added a function which really does not close the socket between send/receive (senddataonly, receivedataonly)
Modified by Anna on 31.10.2012 developed and
*/
#include "genericSocket.h"
#define TCP_PACKET_SIZE 4096
class MySocketTCP : public genericSocket {
public:
// sender (client): where to? ip
MySocketTCP(const char *const host_ip_or_name, uint16_t port_number)
: genericSocket(host_ip_or_name, port_number, TCP) {
setPacketSize(TCP_PACKET_SIZE);
}
// receiver (server) local no need for ip
MySocketTCP(uint16_t port_number)
: genericSocket(port_number, TCP) {
setPacketSize(TCP_PACKET_SIZE);
}
virtual ~MySocketTCP(){};
};

152
slsSupportLib/include/ServerInterface.h
View File

@ -1,152 +0,0 @@
#pragma once
#include "sls_detector_defs.h"
#include "MySocketTCP.h"
/**
* @short the ServerInterface class is the interface between the client and the server
*/
// Do not overload to make it easier for manual comparison between client and server functions
class ServerInterface: public virtual slsDetectorDefs{
public:
/**
* (default) constructor
* @param socket tcp socket between client and receiver
* @param n for debugging purposes (useful only for client side)
* @param t string to identify type (Detector, Receiver) for printouts (useful only for client side)
*/
ServerInterface(MySocketTCP *socket, int n=-1, std::string t="");
/**
* destructor
*/
virtual ~ServerInterface() = default;
/**
* Set the datasocket
* @param socket the data socket
*/
void SetSocket(MySocketTCP *socket);
/**
* Receive ret, mess or retval from Server
* @param ret result of operation
* @param mess pointer to message
* @param retval pointer to retval
* @param sizeOfRetval size of retval
*/
void Client_Receive(int& ret, char* mess, void* retval, int sizeOfRetval);
/**
* Send Arguments to server and receives result back
* @param fnum function enum to determine what parameter
* @param args pointer to arguments
* @param sizeOfArgs argument size
* @param retval pointer to return value
* @param sizeOfRetval return value size
* @param mess pointer to message if message required externally
* @returns success of operation
*/
int Client_Send(int fnum,
void* args, int sizeOfArgs,
void* retval, int sizeOfRetval,
char* mess = 0);
/** only Receiver
* 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
* @returns success of operation
*/
int Server_SendResult(bool update, int ret, void* retval, int retvalSize, char* mess = 0);
/** only Receiver
* Server receives arguments and checks if base object is null (if checkbase is true)
* checking base object is null (for receiver 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);
/** only Receiver
* Server verifies if it is unlocked,
* sets and prints appropriate message if it is locked and different clients
* @param ret pointer to success
* @param mess message
* @param lockstatus status of lock
* @returns success of operaton
*/
int Server_VerifyLock(int& ret, char* mess, int lockstatus);
/** only Receiver
* Server verifies if it is unlocked and idle,
* sets and prints appropriate message if it is locked and different clients
* @param ret pointer to success
* @param mess message
* @param lockstatus status of lock
* @param status 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);
/** only Receiver
* Server sets and prints error message for null object error (receiver only)
* @param ret pointer to success that will be set to FAIL
* @param mess message
*/
void Server_NullObjectError(int& ret, char* mess);
/** only Receiver
* Servers prints error message for socket crash when reading
* @returns always FAIL
*/
int Server_SocketCrash();
/** only Receiver
* Servers sets and prints error message for locked server
* @param ret pointer to success that will be set to FAIL
* @param mess message
* @returns success of operaton
*/
int Server_LockedError(int& ret, char* mess);
/** only Receiver
* Servers sets and prints error message for server not being idle
* @param ret pointer to success 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:
/**
* socket for data acquisition
*/
MySocketTCP *mySocket;
/** index for client debugging purposes */
int index;
/** string for type to differentiate between Detector & Receiver in printouts */
std::string type;
};

3
slsSupportLib/include/sls_detector_defs.h
View File

@ -67,7 +67,7 @@
#define DEFAULT_STREAMING_TIMER_IN_MS 200
typedef char mystring[MAX_STR_LENGTH];
// typedef char mystring[MAX_STR_LENGTH];
#ifdef __cplusplus
class slsDetectorDefs {
@ -496,6 +496,7 @@ format
DBIT_PIPELINE, /**< adc pipeline */
MAX_ADC_PHASE_SHIFT, /** max adc phase shift */
MAX_DBIT_PHASE_SHIFT, /** max adc phase shift */
SYNC_CLOCK,
};
/**