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

format support lib

Browse Source
This commit is contained in:
Erik Frojdh 2020-05-05 10:07:19 +02:00
parent e599bb7c24
commit ea4044e4b1
38 changed files with 775 additions and 854 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -52,7 +52,6 @@ set(ClangFormat_EXCLUDE_PATTERNS "build/"
"slsDetectorCalibration/" "slsDetectorCalibration/"
"slsDetectorServers/" "slsDetectorServers/"
"ctbGui/" "ctbGui/"
"slsSupportLib/"
"manual/" "manual/"
"slsDetectorGui/" "slsDetectorGui/"
"python/" "python/"

2
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -272,7 +272,7 @@ void DataProcessor::ProcessAnImage(char *buf) {
buf + FIFO_HEADER_NUMBYTES, buf + FIFO_HEADER_NUMBYTES,
sizeof(sls_receiver_header) + sizeof(sls_receiver_header) +
(uint32_t)(*((uint32_t *)buf)), //+ size of data (resizable (uint32_t)(*((uint32_t *)buf)), //+ size of data (resizable
//from previous call back // from previous call back
fnum - firstIndex, nump); fnum - firstIndex, nump);
} catch (const sls::RuntimeError &e) { } catch (const sls::RuntimeError &e) {
; // ignore write exception for now (TODO: send error message via ; // ignore write exception for now (TODO: send error message via

10
slsReceiverSoftware/src/Listener.cpp
View File

@ -344,8 +344,9 @@ uint32_t Listener::ListenToAnImage(char *buf) {
// copy packet // copy packet
switch (myDetectorType) { switch (myDetectorType) {
// for gotthard, 1st packet: 4 bytes fnum, CACA // for gotthard, 1st packet: 4 bytes fnum, CACA
// + CACA, 639*2 bytes data 2nd packet: 4 bytes fnum, previous 1*2 bytes // + CACA, 639*2 bytes data 2nd packet: 4 bytes
//data + 640*2 bytes data !! // fnum, previous 1*2 bytes
// data + 640*2 bytes data !!
case GOTTHARD: case GOTTHARD:
if (!pnum) if (!pnum)
memcpy(buf + fifohsize, &carryOverPacket[hsize + 4], dsize - 2); memcpy(buf + fifohsize, &carryOverPacket[hsize + 4], dsize - 2);
@ -514,8 +515,9 @@ uint32_t Listener::ListenToAnImage(char *buf) {
// copy packet // copy packet
switch (myDetectorType) { switch (myDetectorType) {
// for gotthard, 1st packet: 4 bytes fnum, CACA // for gotthard, 1st packet: 4 bytes fnum, CACA
// + CACA, 639*2 bytes data 2nd packet: 4 bytes fnum, previous 1*2 bytes // + CACA, 639*2 bytes data 2nd packet: 4 bytes
//data + 640*2 bytes data !! // fnum, previous 1*2 bytes
// data + 640*2 bytes data !!
case GOTTHARD: case GOTTHARD:
if (!pnum) if (!pnum)
memcpy(buf + fifohsize + (pnum * dsize), memcpy(buf + fifohsize + (pnum * dsize),

7
slsSupportLib/include/DataSocket.h Executable file → Normal file
View File

@ -17,13 +17,12 @@ class DataSocket {
virtual ~DataSocket(); virtual ~DataSocket();
DataSocket &operator=(DataSocket &&move) noexcept; DataSocket &operator=(DataSocket &&move) noexcept;
void swap(DataSocket &other) noexcept; void swap(DataSocket &other) noexcept;
//No copy since the class manage the underlying socket // No copy since the class manage the underlying socket
DataSocket(const DataSocket &) = delete; DataSocket(const DataSocket &) = delete;
DataSocket &operator=(DataSocket const &) = delete; DataSocket &operator=(DataSocket const &) = delete;
int getSocketId() const { return sockfd_; } int getSocketId() const { return sockfd_; }
int Send(const void *buffer, size_t size); int Send(const void *buffer, size_t size);
template <typename T> int Send(T &&data) { template <typename T> int Send(T &&data) {
return Send(&data, sizeof(data)); return Send(&data, sizeof(data));
@ -38,7 +37,7 @@ class DataSocket {
template <typename T> int Receive(T &arg) { template <typename T> int Receive(T &arg) {
return Receive(&arg, sizeof(arg)); return Receive(&arg, sizeof(arg));
} }
template <typename T> T Receive() { template <typename T> T Receive() {
T arg; T arg;
Receive(&arg, sizeof(arg)); Receive(&arg, sizeof(arg));

3
slsSupportLib/include/FixedCapacityContainer.h
View File

@ -104,7 +104,8 @@ template <typename T, size_t Capacity> class FixedCapacityContainer {
} }
} }
template <typename Container> bool is_equal(const Container &c) const noexcept { template <typename Container>
bool is_equal(const Container &c) const noexcept {
if (current_size != c.size()) { if (current_size != c.size()) {
return false; return false;
} else { } else {

2
slsSupportLib/include/ServerSocket.h Executable file → Normal file
View File

@ -18,7 +18,7 @@ class ServerSocket : public DataSocket {
IpAddr getLastClient() const noexcept { return lastClient; } IpAddr getLastClient() const noexcept { return lastClient; }
IpAddr getThisClient() const noexcept { return thisClient; } IpAddr getThisClient() const noexcept { return thisClient; }
IpAddr getLockedBy() const noexcept { return lockedBy; } IpAddr getLockedBy() const noexcept { return lockedBy; }
bool differentClients() const noexcept {return lastClient != thisClient;} bool differentClients() const noexcept { return lastClient != thisClient; }
void setLockedBy(IpAddr addr) { lockedBy = addr; } void setLockedBy(IpAddr addr) { lockedBy = addr; }
void setLastClient(IpAddr addr) { lastClient = addr; } void setLastClient(IpAddr addr) { lastClient = addr; }
int getPort() const noexcept { return serverPort; } int getPort() const noexcept { return serverPort; }

5
slsSupportLib/include/TimeHelper.h
View File

@ -9,9 +9,10 @@ using us = std::chrono::microseconds;
using ms = std::chrono::milliseconds; using ms = std::chrono::milliseconds;
using s = std::chrono::seconds; using s = std::chrono::seconds;
//Absolute value of std::chrono::duration // Absolute value of std::chrono::duration
template <class Rep, class Period> template <class Rep, class Period>
constexpr std::chrono::duration<Rep, Period> abs(std::chrono::duration<Rep, Period> d) { constexpr std::chrono::duration<Rep, Period>
abs(std::chrono::duration<Rep, Period> d) {
return d >= d.zero() ? d : -d; return d >= d.zero() ? d : -d;
} }

19
slsSupportLib/include/Timer.h Executable file → Normal file
View File

@ -4,35 +4,32 @@
#include <iostream> #include <iostream>
#include <string> #include <string>
namespace sls{ namespace sls {
class Timer { class Timer {
using clock = std::chrono::high_resolution_clock; using clock = std::chrono::high_resolution_clock;
using time_point = std::chrono::time_point<clock>; using time_point = std::chrono::time_point<clock>;
public: public:
Timer(std::string name = "0") Timer(std::string name = "0") : t0(clock::now()), name_(name) {}
: t0(clock::now()), name_(name) {
}
double elapsed_ms() { double elapsed_ms() {
return std::chrono::duration<double, std::milli>(clock::now() - t0).count(); return std::chrono::duration<double, std::milli>(clock::now() - t0)
.count();
} }
double elapsed_s() { double elapsed_s() {
return std::chrono::duration<double>(clock::now() - t0).count(); return std::chrono::duration<double>(clock::now() - t0).count();
} }
void print_elapsed() { void print_elapsed() {
std::cout << "Timer \"" << name_ << "\": Elapsed time " << elapsed_ms() << " ms\n"; std::cout << "Timer \"" << name_ << "\": Elapsed time " << elapsed_ms()
} << " ms\n";
void restart() {
t0 = clock::now();
} }
void restart() { t0 = clock::now(); }
private: private:
time_point t0; time_point t0;
std::string name_; std::string name_;
}; };
}; // namespace sls
}; //namespace sls
#endif // TIMER_H #endif // TIMER_H

16
slsSupportLib/include/TypeTraits.h
View File

@ -31,22 +31,23 @@ template <typename... Ts> struct has_str_helper {};
template <typename T> template <typename T>
struct has_str<T, typename std::conditional< struct has_str<T, typename std::conditional<
false, false, has_str_helper<decltype(std::declval<T>().str())>,
has_str_helper<decltype(std::declval<T>().str())>,
void>::type> : public std::true_type {}; void>::type> : public std::true_type {};
/** /**
* Has emplace_back method * Has emplace_back method
*/ */
template <typename T, typename _ = void> struct has_emplace_back : std::false_type {}; template <typename T, typename _ = void>
struct has_emplace_back : std::false_type {};
template <typename... Ts> struct has_emplace_back_helper {}; template <typename... Ts> struct has_emplace_back_helper {};
template <typename T> template <typename T>
struct has_emplace_back<T, typename std::conditional< struct has_emplace_back<
false, T, typename std::conditional<
has_emplace_back_helper<decltype(std::declval<T>().emplace_back())>, false,
void>::type> : public std::true_type {}; has_emplace_back_helper<decltype(std::declval<T>().emplace_back())>,
void>::type> : public std::true_type {};
/** /**
* Type trait to evaluate if template parameter is * Type trait to evaluate if template parameter is
@ -71,7 +72,6 @@ struct is_container<
decltype(std::declval<T>().empty())>, decltype(std::declval<T>().empty())>,
void>::type> : public std::true_type {}; void>::type> : public std::true_type {};
/** /**
* Type trait to evaluate if template parameter is * Type trait to evaluate if template parameter is
* complying with a standard container * complying with a standard container

2
slsSupportLib/include/UdpRxSocket.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
/* /*
UDP socket class to receive data. The intended use is in the UDP socket class to receive data. The intended use is in the
receiver listener loop. Should be used RAII style... receiver listener loop. Should be used RAII style...
*/ */

112
slsSupportLib/include/ZmqSocket.h Executable file → Normal file
View File

@ -15,69 +15,66 @@
// #define ZMQ_DETAIL // #define ZMQ_DETAIL
#define ROIVERBOSITY #define ROIVERBOSITY
class zmq_msg_t; class zmq_msg_t;
#include <map> #include <map>
/** zmq header structure */ /** zmq header structure */
struct zmqHeader { struct zmqHeader {
/** true if incoming data, false if end of acquisition */ /** true if incoming data, false if end of acquisition */
bool data{true}; bool data{true};
uint32_t jsonversion{0}; uint32_t jsonversion{0};
uint32_t dynamicRange{0}; uint32_t dynamicRange{0};
uint64_t fileIndex{0}; uint64_t fileIndex{0};
/** number of detectors in x axis */ /** number of detectors in x axis */
uint32_t ndetx{0}; uint32_t ndetx{0};
/** number of detectors in y axis */ /** number of detectors in y axis */
uint32_t ndety{0}; uint32_t ndety{0};
/** number of pixels/channels in x axis for this zmq socket */ /** number of pixels/channels in x axis for this zmq socket */
uint32_t npixelsx{0}; uint32_t npixelsx{0};
/** number of pixels/channels in y axis for this zmq socket */ /** number of pixels/channels in y axis for this zmq socket */
uint32_t npixelsy{0}; uint32_t npixelsy{0};
/** number of bytes for an image in this socket */ /** number of bytes for an image in this socket */
uint32_t imageSize{0}; uint32_t imageSize{0};
/** frame number from detector */ /** frame number from detector */
uint64_t acqIndex{0}; uint64_t acqIndex{0};
/** frame index (starting at 0 for each acquisition) */ /** frame index (starting at 0 for each acquisition) */
uint64_t frameIndex{0}; uint64_t frameIndex{0};
/** progress in percentage */ /** progress in percentage */
int progress{0}; int progress{0};
/** file name prefix */ /** file name prefix */
std::string fname{""}; std::string fname{""};
/** header from detector */ /** header from detector */
uint64_t frameNumber{0}; uint64_t frameNumber{0};
uint32_t expLength{0}; uint32_t expLength{0};
uint32_t packetNumber{0}; uint32_t packetNumber{0};
uint64_t bunchId{0}; uint64_t bunchId{0};
uint64_t timestamp{0}; uint64_t timestamp{0};
uint16_t modId{0}; uint16_t modId{0};
uint16_t row{0}; uint16_t row{0};
uint16_t column{0}; uint16_t column{0};
uint16_t reserved{0}; uint16_t reserved{0};
uint32_t debug{0}; uint32_t debug{0};
uint16_t roundRNumber{0}; uint16_t roundRNumber{0};
uint8_t detType{0}; uint8_t detType{0};
uint8_t version{0}; uint8_t version{0};
/** if image should be flipped across x axis */ /** if image should be flipped across x axis */
int flippedDataX{0}; int flippedDataX{0};
/** quad type (eiger hardware specific) */ /** quad type (eiger hardware specific) */
uint32_t quad{0}; uint32_t quad{0};
/** true if complete image, else missing packets */ /** true if complete image, else missing packets */
bool completeImage{false}; bool completeImage{false};
/** additional json header */ /** additional json header */
std::map<std::string, std::string> addJsonHeader; std::map<std::string, std::string> addJsonHeader;
}; };
class ZmqSocket { class ZmqSocket {
public: public:
// Socket Options for optimization // Socket Options for optimization
// ZMQ_LINGER default is already -1 means no messages discarded. use this // ZMQ_LINGER default is already -1 means no messages discarded. use this
// options if optimizing required ZMQ_SNDHWM default is 0 means no limit. use // options if optimizing required ZMQ_SNDHWM default is 0 means no limit.
// this to optimize if optimizing required // use this to optimize if optimizing required eg. int value = -1; if
// eg. int value = -1; // (zmq_setsockopt(socketDescriptor, ZMQ_LINGER, &value,sizeof(value))) {
// if (zmq_setsockopt(socketDescriptor, ZMQ_LINGER, &value,sizeof(value))) {
// Close(); // Close();
/** /**
* Constructor for a client * Constructor for a client
@ -174,7 +171,7 @@ class ZmqSocket {
* @returns 0 if error, else 1 * @returns 0 if error, else 1
*/ */
int SendData(char *buf, int length); int SendData(char *buf, int length);
/** /**
* Receive Header * Receive Header
* @param index self index for debugging * @param index self index for debugging
@ -183,7 +180,7 @@ class ZmqSocket {
* @returns 0 if error or end of acquisition, else 1 (call * @returns 0 if error or end of acquisition, else 1 (call
* CloseHeaderMessage after parsing header) * CloseHeaderMessage after parsing header)
*/ */
int ReceiveHeader(const int index, zmqHeader& zHeader, uint32_t version); int ReceiveHeader(const int index, zmqHeader &zHeader, uint32_t version);
/** /**
* Receive Data * Receive Data
@ -200,8 +197,7 @@ class ZmqSocket {
void PrintError(); void PrintError();
private: private:
/**
/**
* Receive Message * Receive Message
* @param index self index for debugging * @param index self index for debugging
* @param message message * @param message message
@ -218,8 +214,8 @@ class ZmqSocket {
* @param version version that has to match, -1 to not care * @param version version that has to match, -1 to not care
* @returns true if successful else false * @returns true if successful else false
*/ */
int ParseHeader(const int index, int length, char *buff, int ParseHeader(const int index, int length, char *buff, zmqHeader &zHeader,
zmqHeader& zHeader, uint32_t version); uint32_t version);
/** /**
* Class to close socket descriptors automatically * Class to close socket descriptors automatically
@ -251,6 +247,4 @@ class ZmqSocket {
/** Socket descriptor */ /** Socket descriptor */
mySocketDescriptors sockfd; mySocketDescriptors sockfd;
}; };

79
slsSupportLib/include/ansi.h Executable file → Normal file
View File

@ -1,26 +1,27 @@
#define RED "\x1b[31m" #define RED "\x1b[31m"
#define GREEN "\x1b[32m" #define GREEN "\x1b[32m"
#define YELLOW "\x1b[33m" #define YELLOW "\x1b[33m"
#define BLUE "\x1b[34m" #define BLUE "\x1b[34m"
#define MAGENTA "\x1b[35m" #define MAGENTA "\x1b[35m"
#define CYAN "\x1b[36m" #define CYAN "\x1b[36m"
#define GRAY "\x1b[37m" #define GRAY "\x1b[37m"
#define DARKGRAY "\x1b[30m" #define DARKGRAY "\x1b[30m"
#define BG_BLACK "\x1b[48;5;232m" #define BG_BLACK "\x1b[48;5;232m"
#define BG_RED "\x1b[41m" #define BG_RED "\x1b[41m"
#define BG_GREEN "\x1b[42m" #define BG_GREEN "\x1b[42m"
#define BG_YELLOW "\x1b[43m" #define BG_YELLOW "\x1b[43m"
#define BG_BLUE "\x1b[44m" #define BG_BLUE "\x1b[44m"
#define BG_MAGENTA "\x1b[45m" #define BG_MAGENTA "\x1b[45m"
#define BG_CYAN "\x1b[46m" #define BG_CYAN "\x1b[46m"
#define RESET "\x1b[0m" #define RESET "\x1b[0m"
#define BOLD "\x1b[1m" #define BOLD "\x1b[1m"
//on background black // on background black
#define bprintf(code, format, ...) printf(code BG_BLACK format RESET, ##__VA_ARGS__) #define bprintf(code, format, ...) \
printf(code BG_BLACK format RESET, ##__VA_ARGS__)
//normal printout // normal printout
#define cprintf(code, format, ...) printf(code format RESET, ##__VA_ARGS__) #define cprintf(code, format, ...) printf(code format RESET, ##__VA_ARGS__)
/* /*
@ -30,11 +31,9 @@ example 1 (a snippet):
#ifdef MARTIN #ifdef MARTIN
cprintf(BLUE, "LL Write - Len: %2d - If: %X - Data: ",buffer_len, ll->ll_fifo_base); cprintf(BLUE, "LL Write - Len: %2d - If: %X - Data: ",buffer_len,
for (i=0; i < buffer_len/4; i++) ll->ll_fifo_base); for (i=0; i < buffer_len/4; i++) cprintf(BLUE, "%.8X
cprintf(BLUE, "%.8X ",*(((unsigned *) buffer)+i)); ",*(((unsigned *) buffer)+i)); printf("\n"); #endif
printf("\n");
#endif
#ifdef MARTIN #ifdef MARTIN
cprintf(CYAN, "LL Read - If: %X - Data: ",ll->ll_fifo_base); cprintf(CYAN, "LL Read - If: %X - Data: ",ll->ll_fifo_base);
@ -46,21 +45,21 @@ example 2:
int main() int main()
{ {
int i=1; int i=1;
printf("Normal %i\n", i); printf("Normal %i\n", i);
cprintf(RED, "Red\n"); cprintf(RED, "Red\n");
cprintf(GREEN, "Green\n"); cprintf(GREEN, "Green\n");
cprintf(YELLOW, "Yellow\n"); cprintf(YELLOW, "Yellow\n");
cprintf(BLUE, "Blue\n"); cprintf(BLUE, "Blue\n");
cprintf(MAGENTA, "Mangenta %i\n", i); cprintf(MAGENTA, "Mangenta %i\n", i);
cprintf(CYAN, "Cyan %i\n", i); cprintf(CYAN, "Cyan %i\n", i);
cprintf(BOLD, "White %i\n", i); cprintf(BOLD, "White %i\n", i);
cprintf(RED BOLD, "Red %i\n", i); cprintf(RED BOLD, "Red %i\n", i);
cprintf(GREEN BOLD, "Green\n"); cprintf(GREEN BOLD, "Green\n");
cprintf(YELLOW BOLD, "Yellow\n"); cprintf(YELLOW BOLD, "Yellow\n");
cprintf(BLUE BOLD, "Blue\n"); cprintf(BLUE BOLD, "Blue\n");
cprintf(MAGENTA BOLD, "Mangenta %i\n", i); cprintf(MAGENTA BOLD, "Mangenta %i\n", i);
cprintf(CYAN BOLD, "Cyan %i\n", i); cprintf(CYAN BOLD, "Cyan %i\n", i);
} }
*/ */

5
slsSupportLib/include/container_utils.h Executable file → Normal file
View File

@ -39,7 +39,7 @@ template <typename Container> bool allEqual(const Container &c) {
return false; return false;
} }
/** /**
* Compare elements but with specified tolerance, useful * Compare elements but with specified tolerance, useful
* for floating point values. * for floating point values.
*/ */
@ -129,7 +129,7 @@ minusOneIfDifferent(const std::vector<std::array<T, size>> &container) {
return arr; return arr;
} }
/** /**
* Return the first value if all values are equal * Return the first value if all values are equal
* otherwise return default_value. If no default * otherwise return default_value. If no default
* value is supplied it will be default constructed * value is supplied it will be default constructed
@ -146,7 +146,6 @@ Squash(const Container &c, typename Container::value_type default_value = {}) {
return default_value; return default_value;
} }
} // namespace sls } // namespace sls
#endif // CONTAINER_UTILS_H #endif // CONTAINER_UTILS_H

18
slsSupportLib/include/file_utils.h Executable file → Normal file
View File

@ -1,13 +1,11 @@
#pragma once #pragma once
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
#include <cstdio> #include <cstdio>
#include <fstream> #include <fstream>
#include <string> #include <string>
/** (used by multi and sls) /** (used by multi and sls)
* reads a short int raw data file * reads a short int raw data file
* @param infile input file stream * @param infile input file stream
@ -16,8 +14,8 @@
* @param offset start channel value * @param offset start channel value
* @returns OK or FAIL if it could not read the file or data=NULL * @returns OK or FAIL if it could not read the file or data=NULL
*/ */
int readDataFile(std::ifstream &infile, short int *data, int nch, int offset=0); int readDataFile(std::ifstream &infile, short int *data, int nch,
int offset = 0);
/** (used by multi and sls) /** (used by multi and sls)
* reads a short int rawdata file * reads a short int rawdata file
@ -28,7 +26,6 @@ int readDataFile(std::ifstream &infile, short int *data, int nch, int offset=0);
*/ */
int readDataFile(std::string fname, short int *data, int nch); int readDataFile(std::string fname, short int *data, int nch);
/** (used by multi and sls) /** (used by multi and sls)
* writes a short int raw data file * writes a short int raw data file
* @param outfile output file stream * @param outfile output file stream
@ -37,9 +34,8 @@ int readDataFile(std::string fname, short int *data, int nch);
* @param offset start channel number * @param offset start channel number
* @returns OK or FAIL if it could not write the file or data=NULL * @returns OK or FAIL if it could not write the file or data=NULL
*/ */
int writeDataFile(std::ofstream &outfile,int nch, short int *data, int offset=0); int writeDataFile(std::ofstream &outfile, int nch, short int *data,
int offset = 0);
/** (used by multi and sls) /** (used by multi and sls)
* writes a short int raw data file * writes a short int raw data file
@ -48,9 +44,7 @@ int writeDataFile(std::ofstream &outfile,int nch, short int *data, int offset=0
* @param data array of data values * @param data array of data values
* @returns OK or FAIL if it could not write the file or data=NULL * @returns OK or FAIL if it could not write the file or data=NULL
*/ */
int writeDataFile(std::string fname,int nch, short int *data); int writeDataFile(std::string fname, int nch, short int *data);
// mkdir -p path implemented by recursive calls // mkdir -p path implemented by recursive calls
void mkdir_p(const std::string& path, std::string dir=""); void mkdir_p(const std::string &path, std::string dir = "");

36
slsSupportLib/include/logger.h
View File

@ -1,27 +1,39 @@
#pragma once #pragma once
/*Utility to log to console*/ /*Utility to log to console*/
#include "ansi.h" //Colors #include "ansi.h" //Colors
#include <sys/time.h>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <sys/time.h>
enum TLogLevel {logERROR, logWARNING, logINFOBLUE, logINFOGREEN, logINFORED, logINFO, enum TLogLevel {
logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, logDEBUG5}; logERROR,
logWARNING,
logINFOBLUE,
logINFOGREEN,
logINFORED,
logINFO,
logDEBUG,
logDEBUG1,
logDEBUG2,
logDEBUG3,
logDEBUG4,
logDEBUG5
};
// Compiler should optimize away anything below this value // Compiler should optimize away anything below this value
#ifndef LOG_MAX_REPORTING_LEVEL #ifndef LOG_MAX_REPORTING_LEVEL
#define LOG_MAX_REPORTING_LEVEL logINFO #define LOG_MAX_REPORTING_LEVEL logINFO
#endif #endif
#define __AT__ std::string(__FILE__) + std::string("::") + std::string(__func__) + std::string("(): ") #define __AT__ \
#define __SHORT_FORM_OF_FILE__ \ std::string(__FILE__) + std::string("::") + std::string(__func__) + \
(strrchr(__FILE__,'/') \ std::string("(): ")
? strrchr(__FILE__,'/')+1 \ #define __SHORT_FORM_OF_FILE__ \
: __FILE__ \ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
) #define __SHORT_AT__ \
#define __SHORT_AT__ std::string(__SHORT_FORM_OF_FILE__) + std::string("::") + std::string(__func__) + std::string("(): ") std::string(__SHORT_FORM_OF_FILE__) + std::string("::") + \
std::string(__func__) + std::string("(): ")
namespace sls { namespace sls {
class Logger { class Logger {

6
slsSupportLib/include/network_utils.h Executable file → Normal file
View File

@ -60,9 +60,9 @@ class MacAddr {
}; };
IpAddr HostnameToIp(const char *hostname); IpAddr HostnameToIp(const char *hostname);
std::string IpToInterfaceName(const std::string& ip); std::string IpToInterfaceName(const std::string &ip);
MacAddr InterfaceNameToMac(const std::string& inf); MacAddr InterfaceNameToMac(const std::string &inf);
IpAddr InterfaceNameToIp(const std::string& ifn); IpAddr InterfaceNameToIp(const std::string &ifn);
std::ostream &operator<<(std::ostream &out, const IpAddr &addr); std::ostream &operator<<(std::ostream &out, const IpAddr &addr);
std::ostream &operator<<(std::ostream &out, const MacAddr &addr); std::ostream &operator<<(std::ostream &out, const MacAddr &addr);

154
slsSupportLib/include/sls_detector_defs.h Executable file → Normal file
View File

@ -15,28 +15,27 @@
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
//C++ includes // C++ includes
#include "sls_detector_exceptions.h" #include "sls_detector_exceptions.h"
#include <algorithm> #include <algorithm>
#include <bitset> #include <bitset>
#include <cstdint> #include <cstdint>
#include <string> #include <string>
#else #else
//C includes // C includes
#include <stdint.h> #include <stdint.h>
#endif #endif
#define BIT32_MASK 0xFFFFFFFF #define BIT32_MASK 0xFFFFFFFF
#define MAX_RX_DBIT 64 #define MAX_RX_DBIT 64
/** default ports */ /** default ports */
#define DEFAULT_PORTNO 1952 #define DEFAULT_PORTNO 1952
#define DEFAULT_UDP_PORTNO 50001 #define DEFAULT_UDP_PORTNO 50001
#define DEFAULT_ZMQ_CL_PORTNO 30001 #define DEFAULT_ZMQ_CL_PORTNO 30001
#define DEFAULT_ZMQ_RX_PORTNO 30001 #define DEFAULT_ZMQ_RX_PORTNO 30001
#define SLS_DETECTOR_HEADER_VERSION 0x2 #define SLS_DETECTOR_HEADER_VERSION 0x2
#define SLS_DETECTOR_JSON_HEADER_VERSION 0x4 #define SLS_DETECTOR_JSON_HEADER_VERSION 0x4
// ctb/ moench 1g udp (read from fifo) // ctb/ moench 1g udp (read from fifo)
@ -54,18 +53,17 @@
/** get flag form most functions */ /** get flag form most functions */
#define GET_FLAG -1 #define GET_FLAG -1
#define DEFAULT_DET_MAC "00:aa:bb:cc:dd:ee" #define DEFAULT_DET_MAC "00:aa:bb:cc:dd:ee"
#define DEFAULT_DET_IP "129.129.202.45" #define DEFAULT_DET_IP "129.129.202.45"
#define DEFAULT_DET_MAC2 "00:aa:bb:cc:dd:ff" #define DEFAULT_DET_MAC2 "00:aa:bb:cc:dd:ff"
#define DEFAULT_DET_IP2 "129.129.202.46" #define DEFAULT_DET_IP2 "129.129.202.46"
/** default maximum string length */ /** default maximum string length */
#define MAX_STR_LENGTH 1000 #define MAX_STR_LENGTH 1000
#define SHORT_STR_LENGTH 20 #define SHORT_STR_LENGTH 20
#define DEFAULT_STREAMING_TIMER_IN_MS 200 #define DEFAULT_STREAMING_TIMER_IN_MS 200
#ifdef __cplusplus #ifdef __cplusplus
class slsDetectorDefs { class slsDetectorDefs {
public: public:
@ -73,10 +71,10 @@ class slsDetectorDefs {
/** Type of the detector */ /** Type of the detector */
enum detectorType { enum detectorType {
GET_DETECTOR_TYPE = -1, GET_DETECTOR_TYPE = -1,
GENERIC, GENERIC,
EIGER, EIGER,
GOTTHARD, GOTTHARD,
JUNGFRAU, JUNGFRAU,
CHIPTESTBOARD, CHIPTESTBOARD,
MOENCH, MOENCH,
@ -86,7 +84,7 @@ class slsDetectorDefs {
/** return values */ /** return values */
enum { enum {
OK, /**< function succeeded */ OK, /**< function succeeded */
FAIL /**< function failed */ FAIL /**< function failed */
}; };
@ -143,7 +141,7 @@ class slsDetectorDefs {
#define MAX_NUM_PACKETS 512 #define MAX_NUM_PACKETS 512
using sls_bitset = std::bitset<MAX_NUM_PACKETS>; using sls_bitset = std::bitset<MAX_NUM_PACKETS>;
using bitset_storage = uint8_t[MAX_NUM_PACKETS / 8]; using bitset_storage = uint8_t[MAX_NUM_PACKETS / 8];
struct sls_receiver_header{ struct sls_receiver_header {
sls_detector_header detHeader; /**< is the detector header */ sls_detector_header detHeader; /**< is the detector header */
sls_bitset packetsMask; /**< is the packets caught bit mask */ sls_bitset packetsMask; /**< is the packets caught bit mask */
}; };
@ -171,24 +169,23 @@ class slsDetectorDefs {
xmin,xmax,ymin,ymax define the limits of the region xmin,xmax,ymin,ymax define the limits of the region
*/ */
#ifdef __cplusplus #ifdef __cplusplus
struct ROI { struct ROI {
int xmin{-1}; /**< is the roi xmin (in channel number) */ int xmin{-1}; /**< is the roi xmin (in channel number) */
int xmax{-1}; /**< is the roi xmax (in channel number)*/ int xmax{-1}; /**< is the roi xmax (in channel number)*/
}__attribute__((packed)); } __attribute__((packed));
#else #else
typedef struct { typedef struct {
int xmin; /**< is the roi xmin (in channel number) */ int xmin; /**< is the roi xmin (in channel number) */
int xmax; /**< is the roi xmax (in channel number)*/ int xmax; /**< is the roi xmax (in channel number)*/
} ROI; } ROI;
#endif #endif
/** /**
type of action performed (for text client) type of action performed (for text client)
*/ */
enum { GET_ACTION, PUT_ACTION, READOUT_ACTION, HELP_ACTION }; enum { GET_ACTION, PUT_ACTION, READOUT_ACTION, HELP_ACTION };
/** /**
dimension indexes dimension indexes
*/ */
@ -202,11 +199,10 @@ class slsDetectorDefs {
int x{0}; int x{0};
int y{0}; int y{0};
xy() = default; xy() = default;
xy(int x, int y):x(x),y(y){}; xy(int x, int y) : x(x), y(y){};
}__attribute__((packed)); } __attribute__((packed));
#endif #endif
/** /**
use of the external signals use of the external signals
*/ */
@ -241,10 +237,10 @@ class slsDetectorDefs {
*/ */
enum timingMode { enum timingMode {
GET_TIMING_MODE = -1, /**<return flag for communication mode */ GET_TIMING_MODE = -1, /**<return flag for communication mode */
AUTO_TIMING, /**< internal timing */ AUTO_TIMING, /**< internal timing */
TRIGGER_EXPOSURE, /**< trigger mode i.e. exposure is triggered */ TRIGGER_EXPOSURE, /**< trigger mode i.e. exposure is triggered */
GATED, /**< gated */ GATED, /**< gated */
BURST_TRIGGER, /**< trigger a burst of frames */ BURST_TRIGGER, /**< trigger a burst of frames */
NUM_TIMING_MODES NUM_TIMING_MODES
}; };
@ -297,27 +293,27 @@ class slsDetectorDefs {
VIPRE, VIPRE,
VIINSH, VIINSH,
VDCSH, VDCSH,
VTH2, VTH2,
VPL, VPL,
VTH3, VTH3,
CASSH, CASSH,
CAS, CAS,
VICIN, VICIN,
VIPRE_OUT, VIPRE_OUT,
VREF_H_ADC, VREF_H_ADC,
VB_COMP_FE, VB_COMP_FE,
VB_COMP_ADC, VB_COMP_ADC,
VCOM_CDS, VCOM_CDS,
VREF_RSTORE, VREF_RSTORE,
VB_OPA_1ST, VB_OPA_1ST,
VREF_COMP_FE, VREF_COMP_FE,
VCOM_ADC1, VCOM_ADC1,
VREF_PRECH, VREF_PRECH,
VREF_L_ADC, VREF_L_ADC,
VREF_CDS, VREF_CDS,
VB_CS, VB_CS,
VB_OPA_FD, VB_OPA_FD,
VCOM_ADC2, VCOM_ADC2,
VB_DS, VB_DS,
VB_COMP, VB_COMP,
VB_PIXBUF, VB_PIXBUF,
@ -339,7 +335,7 @@ class slsDetectorDefs {
I_POWER_C = 108, I_POWER_C = 108,
I_POWER_D = 109, I_POWER_D = 109,
I_POWER_IO = 110, I_POWER_IO = 110,
V_LIMIT = 111, V_LIMIT = 111,
SLOW_ADC0 = 1000, SLOW_ADC0 = 1000,
SLOW_ADC1, SLOW_ADC1,
SLOW_ADC2, SLOW_ADC2,
@ -355,20 +351,20 @@ class slsDetectorDefs {
detector settings indexes detector settings indexes
*/ */
enum detectorSettings { enum detectorSettings {
GET_SETTINGS = -1, GET_SETTINGS = -1,
STANDARD, STANDARD,
FAST, FAST,
HIGHGAIN, HIGHGAIN,
DYNAMICGAIN, DYNAMICGAIN,
LOWGAIN, LOWGAIN,
MEDIUMGAIN, MEDIUMGAIN,
VERYHIGHGAIN, VERYHIGHGAIN,
DYNAMICHG0, DYNAMICHG0,
FIXGAIN1, FIXGAIN1,
FIXGAIN2, FIXGAIN2,
FORCESWITCHG1, FORCESWITCHG1,
FORCESWITCHG2, FORCESWITCHG2,
VERYLOWGAIN, VERYLOWGAIN,
G1_HIGHGAIN, G1_HIGHGAIN,
G1_LOWGAIN, G1_LOWGAIN,
G2_HIGHCAP_HIGHGAIN, G2_HIGHCAP_HIGHGAIN,
@ -377,34 +373,21 @@ class slsDetectorDefs {
G2_LOWCAP_LOWGAIN, G2_LOWCAP_LOWGAIN,
G4_HIGHGAIN, G4_HIGHGAIN,
G4_LOWGAIN, G4_LOWGAIN,
UNDEFINED = 200, /**< undefined or custom settings */ UNDEFINED = 200, /**< undefined or custom settings */
UNINITIALIZED /**< uninitialiazed (status at startup) */ UNINITIALIZED /**< uninitialiazed (status at startup) */
}; };
#define TRIMBITMASK 0x3f #define TRIMBITMASK 0x3f
enum clockIndex { enum clockIndex { ADC_CLOCK, DBIT_CLOCK, RUN_CLOCK, SYNC_CLOCK };
ADC_CLOCK,
DBIT_CLOCK,
RUN_CLOCK,
SYNC_CLOCK
};
/** /**
* read out mode (ctb, moench) * read out mode (ctb, moench)
*/ */
enum readoutMode { enum readoutMode { ANALOG_ONLY, DIGITAL_ONLY, ANALOG_AND_DIGITAL };
ANALOG_ONLY,
DIGITAL_ONLY,
ANALOG_AND_DIGITAL
};
/** chip speed */ /** chip speed */
enum speedLevel { enum speedLevel { FULL_SPEED, HALF_SPEED, QUARTER_SPEED };
FULL_SPEED,
HALF_SPEED,
QUARTER_SPEED
};
/** port type */ /** port type */
enum portType { enum portType {
@ -447,23 +430,20 @@ class slsDetectorDefs {
*/ */
enum burstMode { enum burstMode {
BURST_OFF, BURST_OFF,
BURST_INTERNAL, BURST_INTERNAL,
BURST_EXTERNAL, BURST_EXTERNAL,
NUM_BURST_MODES NUM_BURST_MODES
}; };
/** /**
* timing source for gotthard2 * timing source for gotthard2
*/ */
enum timingSourceType { enum timingSourceType { TIMING_INTERNAL, TIMING_EXTERNAL };
TIMING_INTERNAL,
TIMING_EXTERNAL
};
#ifdef __cplusplus #ifdef __cplusplus
/** /**
* structure to udpate receiver * structure to udpate receiver
*/ */
struct rxParameters { struct rxParameters {
detectorType detType{GENERIC}; detectorType detType{GENERIC};
xy multiSize; xy multiSize;
@ -496,7 +476,7 @@ class slsDetectorDefs {
ROI roi; ROI roi;
uint32_t countermask{0}; uint32_t countermask{0};
burstMode burstType{BURST_OFF}; burstMode burstType{BURST_OFF};
}__attribute__((packed)); } __attribute__((packed));
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
@ -571,9 +551,10 @@ struct detParameters {
nChipX = 10; nChipX = 10;
nChipY = 1; nChipY = 1;
nDacs = 14; nDacs = 14;
break; break;
default: default:
throw sls::RuntimeError("Unknown detector type! " + std::to_string(type)); throw sls::RuntimeError("Unknown detector type! " +
std::to_string(type));
} }
} }
}; };
@ -659,11 +640,10 @@ typedef struct {
} sls_detector_module; } sls_detector_module;
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
//TODO! discuss this // TODO! discuss this
#include <vector> //hmm... but currently no way around #include <vector> //hmm... but currently no way around
namespace sls{ namespace sls {
using Positions = const std::vector<int> &; using Positions = const std::vector<int> &;
using defs = slsDetectorDefs; using defs = slsDetectorDefs;
} // namespace sls } // namespace sls

51
slsSupportLib/include/sls_detector_exceptions.h Executable file → Normal file
View File

@ -4,57 +4,52 @@
#include <iostream> #include <iostream>
#include <stdexcept> #include <stdexcept>
namespace sls{ namespace sls {
struct RuntimeError : public std::runtime_error { struct RuntimeError : public std::runtime_error {
public: public:
RuntimeError(): runtime_error("SLS Detector Package Failed") { RuntimeError() : runtime_error("SLS Detector Package Failed") {
LOG(logERROR) << "SLS Detector Package Failed"; LOG(logERROR) << "SLS Detector Package Failed";
} }
RuntimeError(const std::string& msg): runtime_error(msg) { RuntimeError(const std::string &msg) : runtime_error(msg) {
LOG(logERROR) << msg; LOG(logERROR) << msg;
} }
RuntimeError(const char* msg): runtime_error(msg) { RuntimeError(const char *msg) : runtime_error(msg) { LOG(logERROR) << msg; }
LOG(logERROR) << msg;
}
}; };
struct SharedMemoryError : public RuntimeError { struct SharedMemoryError : public RuntimeError {
public: public:
SharedMemoryError(const std::string& msg):RuntimeError(msg) {} SharedMemoryError(const std::string &msg) : RuntimeError(msg) {}
}; };
struct SocketError : public RuntimeError { struct SocketError : public RuntimeError {
public: public:
SocketError(const std::string& msg):RuntimeError(msg) {} SocketError(const std::string &msg) : RuntimeError(msg) {}
}; };
struct ZmqSocketError : public RuntimeError { struct ZmqSocketError : public RuntimeError {
public: public:
ZmqSocketError(const std::string& msg):RuntimeError(msg) {} ZmqSocketError(const std::string &msg) : RuntimeError(msg) {}
}; };
struct NotImplementedError : public RuntimeError { struct NotImplementedError : public RuntimeError {
public: public:
NotImplementedError(const std::string& msg):RuntimeError(msg) {} NotImplementedError(const std::string &msg) : RuntimeError(msg) {}
}; };
struct DetectorError : public RuntimeError { struct DetectorError : public RuntimeError {
public: public:
DetectorError(const std::string& msg):RuntimeError(msg) {} DetectorError(const std::string &msg) : RuntimeError(msg) {}
}; };
struct ReceiverError : public RuntimeError { struct ReceiverError : public RuntimeError {
public: public:
ReceiverError(const std::string& msg):RuntimeError(msg) {} ReceiverError(const std::string &msg) : RuntimeError(msg) {}
}; };
struct GuiError : public RuntimeError { struct GuiError : public RuntimeError {
public: public:
GuiError(const std::string& msg):RuntimeError(msg) {} GuiError(const std::string &msg) : RuntimeError(msg) {}
}; };
} // namespace sls } // namespace sls

566
slsSupportLib/include/sls_detector_funcs.h
View File

@ -8,293 +8,294 @@
*@short functions indices to call on server (detector/receiver) *@short functions indices to call on server (detector/receiver)
*/ */
enum detFuncs {
F_EXEC_COMMAND = 0,
F_GET_DETECTOR_TYPE,
F_SET_EXTERNAL_SIGNAL_FLAG,
F_SET_TIMING_MODE,
F_GET_FIRMWARE_VERSION,
F_GET_SERVER_VERSION,
F_GET_SERIAL_NUMBER,
F_SET_FIRMWARE_TEST,
F_SET_BUS_TEST,
F_SET_IMAGE_TEST_MODE,
F_GET_IMAGE_TEST_MODE,
F_SET_DAC,
F_GET_ADC,
F_WRITE_REGISTER,
F_READ_REGISTER,
F_SET_MODULE,
F_GET_MODULE,
F_SET_SETTINGS,
F_GET_THRESHOLD_ENERGY,
F_START_ACQUISITION,
F_STOP_ACQUISITION,
F_START_READOUT,
F_GET_RUN_STATUS,
F_START_AND_READ_ALL,
F_READ_ALL,
F_GET_NUM_FRAMES,
F_SET_NUM_FRAMES,
F_GET_NUM_TRIGGERS,
F_SET_NUM_TRIGGERS,
F_GET_NUM_ADDITIONAL_STORAGE_CELLS,
F_SET_NUM_ADDITIONAL_STORAGE_CELLS,
F_GET_NUM_ANALOG_SAMPLES,
F_SET_NUM_ANALOG_SAMPLES,
F_GET_NUM_DIGITAL_SAMPLES,
F_SET_NUM_DIGITAL_SAMPLES,
F_GET_EXPTIME,
F_SET_EXPTIME,
F_GET_PERIOD,
F_SET_PERIOD,
F_GET_DELAY_AFTER_TRIGGER,
F_SET_DELAY_AFTER_TRIGGER,
F_GET_SUB_EXPTIME,
F_SET_SUB_EXPTIME,
F_GET_SUB_DEADTIME,
F_SET_SUB_DEADTIME,
F_GET_STORAGE_CELL_DELAY,
F_SET_STORAGE_CELL_DELAY,
F_GET_FRAMES_LEFT,
F_GET_TRIGGERS_LEFT,
F_GET_EXPTIME_LEFT,
F_GET_PERIOD_LEFT,
F_GET_DELAY_AFTER_TRIGGER_LEFT,
F_GET_MEASURED_PERIOD,
F_GET_MEASURED_SUBPERIOD,
F_GET_FRAMES_FROM_START,
F_GET_ACTUAL_TIME,
F_GET_MEASUREMENT_TIME,
F_SET_DYNAMIC_RANGE,
F_SET_ROI,
F_GET_ROI,
F_EXIT_SERVER,
F_LOCK_SERVER,
F_GET_LAST_CLIENT_IP,
F_SET_PORT,
F_ENABLE_TEN_GIGA,
F_SET_ALL_TRIMBITS,
F_SET_PATTERN_IO_CONTROL,
F_SET_PATTERN_CLOCK_CONTROL,
F_SET_PATTERN_WORD,
F_SET_PATTERN_LOOP_ADDRESSES,
F_SET_PATTERN_LOOP_CYCLES,
F_SET_PATTERN_WAIT_ADDR,
F_SET_PATTERN_WAIT_TIME,
F_SET_PATTERN_MASK,
F_GET_PATTERN_MASK,
F_SET_PATTERN_BIT_MASK,
F_GET_PATTERN_BIT_MASK,
F_WRITE_ADC_REG,
F_SET_COUNTER_BIT,
F_PULSE_PIXEL,
F_PULSE_PIXEL_AND_MOVE,
F_PULSE_CHIP,
F_SET_RATE_CORRECT,
F_GET_RATE_CORRECT,
F_SET_TEN_GIGA_FLOW_CONTROL,
F_GET_TEN_GIGA_FLOW_CONTROL,
F_SET_TRANSMISSION_DELAY_FRAME,
F_GET_TRANSMISSION_DELAY_FRAME,
F_SET_TRANSMISSION_DELAY_LEFT,
F_GET_TRANSMISSION_DELAY_LEFT,
F_SET_TRANSMISSION_DELAY_RIGHT,
F_GET_TRANSMISSION_DELAY_RIGHT,
F_PROGRAM_FPGA,
F_RESET_FPGA,
F_POWER_CHIP,
F_ACTIVATE,
F_PREPARE_ACQUISITION,
F_THRESHOLD_TEMP,
F_TEMP_CONTROL,
F_TEMP_EVENT,
F_AUTO_COMP_DISABLE,
F_STORAGE_CELL_START,
F_CHECK_VERSION,
F_SOFTWARE_TRIGGER,
F_LED,
F_DIGITAL_IO_DELAY,
F_COPY_DET_SERVER,
F_REBOOT_CONTROLLER,
F_SET_ADC_ENABLE_MASK,
F_GET_ADC_ENABLE_MASK,
F_SET_ADC_INVERT,
F_GET_ADC_INVERT,
F_EXTERNAL_SAMPLING_SOURCE,
F_EXTERNAL_SAMPLING,
F_SET_STARTING_FRAME_NUMBER,
F_GET_STARTING_FRAME_NUMBER,
F_SET_QUAD,
F_GET_QUAD,
F_SET_INTERRUPT_SUBFRAME,
F_GET_INTERRUPT_SUBFRAME,
F_SET_READ_N_LINES,
F_GET_READ_N_LINES,
F_SET_POSITION,
F_SET_SOURCE_UDP_MAC,
F_GET_SOURCE_UDP_MAC,
F_SET_SOURCE_UDP_MAC2,
F_GET_SOURCE_UDP_MAC2,
F_SET_SOURCE_UDP_IP,
F_GET_SOURCE_UDP_IP,
F_SET_SOURCE_UDP_IP2,
F_GET_SOURCE_UDP_IP2,
F_SET_DEST_UDP_MAC,
F_GET_DEST_UDP_MAC,
F_SET_DEST_UDP_MAC2,
F_GET_DEST_UDP_MAC2,
F_SET_DEST_UDP_IP,
F_GET_DEST_UDP_IP,
F_SET_DEST_UDP_IP2,
F_GET_DEST_UDP_IP2,
F_SET_DEST_UDP_PORT,
F_GET_DEST_UDP_PORT,
F_SET_DEST_UDP_PORT2,
F_GET_DEST_UDP_PORT2,
F_SET_NUM_INTERFACES,
F_GET_NUM_INTERFACES,
F_SET_INTERFACE_SEL,
F_GET_INTERFACE_SEL,
F_SET_PARALLEL_MODE,
F_GET_PARALLEL_MODE,
F_SET_OVERFLOW_MODE,
F_GET_OVERFLOW_MODE,
F_SET_STOREINRAM_MODE,
F_GET_STOREINRAM_MODE,
F_SET_READOUT_MODE,
F_GET_READOUT_MODE,
F_SET_CLOCK_FREQUENCY,
F_GET_CLOCK_FREQUENCY,
F_SET_CLOCK_PHASE,
F_GET_CLOCK_PHASE,
F_GET_MAX_CLOCK_PHASE_SHIFT,
F_SET_CLOCK_DIVIDER,
F_GET_CLOCK_DIVIDER,
F_SET_PIPELINE,
F_GET_PIPELINE,
F_SET_ON_CHIP_DAC,
F_GET_ON_CHIP_DAC,
F_SET_INJECT_CHANNEL,
F_GET_INJECT_CHANNEL,
F_SET_VETO_PHOTON,
F_GET_VETO_PHOTON,
F_SET_VETO_REFERENCE,
F_GET_BURST_MODE,
F_SET_BURST_MODE,
F_SET_ADC_ENABLE_MASK_10G,
F_GET_ADC_ENABLE_MASK_10G,
F_SET_COUNTER_MASK,
F_GET_COUNTER_MASK,
F_GET_NUM_BURSTS,
F_SET_NUM_BURSTS,
F_GET_BURST_PERIOD,
F_SET_BURST_PERIOD,
F_GET_CURRENT_SOURCE,
F_SET_CURRENT_SOURCE,
F_GET_TIMING_SOURCE,
F_SET_TIMING_SOURCE,
F_GET_NUM_CHANNELS,
F_UPDATE_RATE_CORRECTION,
F_GET_RECEIVER_PARAMETERS,
enum detFuncs{ NUM_DET_FUNCTIONS,
F_EXEC_COMMAND=0, RECEIVER_ENUM_START = 256, /**< detector function should not exceed this
F_GET_DETECTOR_TYPE, (detector server should not compile anyway) */
F_SET_EXTERNAL_SIGNAL_FLAG,
F_SET_TIMING_MODE,
F_GET_FIRMWARE_VERSION,
F_GET_SERVER_VERSION,
F_GET_SERIAL_NUMBER,
F_SET_FIRMWARE_TEST,
F_SET_BUS_TEST,
F_SET_IMAGE_TEST_MODE,
F_GET_IMAGE_TEST_MODE,
F_SET_DAC,
F_GET_ADC,
F_WRITE_REGISTER,
F_READ_REGISTER,
F_SET_MODULE,
F_GET_MODULE,
F_SET_SETTINGS,
F_GET_THRESHOLD_ENERGY,
F_START_ACQUISITION,
F_STOP_ACQUISITION,
F_START_READOUT,
F_GET_RUN_STATUS,
F_START_AND_READ_ALL,
F_READ_ALL,
F_GET_NUM_FRAMES,
F_SET_NUM_FRAMES,
F_GET_NUM_TRIGGERS,
F_SET_NUM_TRIGGERS,
F_GET_NUM_ADDITIONAL_STORAGE_CELLS,
F_SET_NUM_ADDITIONAL_STORAGE_CELLS,
F_GET_NUM_ANALOG_SAMPLES,
F_SET_NUM_ANALOG_SAMPLES,
F_GET_NUM_DIGITAL_SAMPLES,
F_SET_NUM_DIGITAL_SAMPLES,
F_GET_EXPTIME,
F_SET_EXPTIME,
F_GET_PERIOD,
F_SET_PERIOD,
F_GET_DELAY_AFTER_TRIGGER,
F_SET_DELAY_AFTER_TRIGGER,
F_GET_SUB_EXPTIME,
F_SET_SUB_EXPTIME,
F_GET_SUB_DEADTIME,
F_SET_SUB_DEADTIME,
F_GET_STORAGE_CELL_DELAY,
F_SET_STORAGE_CELL_DELAY,
F_GET_FRAMES_LEFT,
F_GET_TRIGGERS_LEFT,
F_GET_EXPTIME_LEFT,
F_GET_PERIOD_LEFT,
F_GET_DELAY_AFTER_TRIGGER_LEFT,
F_GET_MEASURED_PERIOD,
F_GET_MEASURED_SUBPERIOD,
F_GET_FRAMES_FROM_START,
F_GET_ACTUAL_TIME,
F_GET_MEASUREMENT_TIME,
F_SET_DYNAMIC_RANGE,
F_SET_ROI,
F_GET_ROI,
F_EXIT_SERVER,
F_LOCK_SERVER,
F_GET_LAST_CLIENT_IP,
F_SET_PORT,
F_ENABLE_TEN_GIGA,
F_SET_ALL_TRIMBITS,
F_SET_PATTERN_IO_CONTROL,
F_SET_PATTERN_CLOCK_CONTROL,
F_SET_PATTERN_WORD,
F_SET_PATTERN_LOOP_ADDRESSES,
F_SET_PATTERN_LOOP_CYCLES,
F_SET_PATTERN_WAIT_ADDR,
F_SET_PATTERN_WAIT_TIME,
F_SET_PATTERN_MASK,
F_GET_PATTERN_MASK,
F_SET_PATTERN_BIT_MASK,
F_GET_PATTERN_BIT_MASK,
F_WRITE_ADC_REG,
F_SET_COUNTER_BIT,
F_PULSE_PIXEL,
F_PULSE_PIXEL_AND_MOVE,
F_PULSE_CHIP,
F_SET_RATE_CORRECT,
F_GET_RATE_CORRECT,
F_SET_TEN_GIGA_FLOW_CONTROL,
F_GET_TEN_GIGA_FLOW_CONTROL,
F_SET_TRANSMISSION_DELAY_FRAME,
F_GET_TRANSMISSION_DELAY_FRAME,
F_SET_TRANSMISSION_DELAY_LEFT,
F_GET_TRANSMISSION_DELAY_LEFT,
F_SET_TRANSMISSION_DELAY_RIGHT,
F_GET_TRANSMISSION_DELAY_RIGHT,
F_PROGRAM_FPGA,
F_RESET_FPGA,
F_POWER_CHIP,
F_ACTIVATE,
F_PREPARE_ACQUISITION,
F_THRESHOLD_TEMP,
F_TEMP_CONTROL,
F_TEMP_EVENT,
F_AUTO_COMP_DISABLE,
F_STORAGE_CELL_START,
F_CHECK_VERSION,
F_SOFTWARE_TRIGGER,
F_LED,
F_DIGITAL_IO_DELAY,
F_COPY_DET_SERVER,
F_REBOOT_CONTROLLER,
F_SET_ADC_ENABLE_MASK,
F_GET_ADC_ENABLE_MASK,
F_SET_ADC_INVERT,
F_GET_ADC_INVERT,
F_EXTERNAL_SAMPLING_SOURCE,
F_EXTERNAL_SAMPLING,
F_SET_STARTING_FRAME_NUMBER,
F_GET_STARTING_FRAME_NUMBER,
F_SET_QUAD,
F_GET_QUAD,
F_SET_INTERRUPT_SUBFRAME,
F_GET_INTERRUPT_SUBFRAME,
F_SET_READ_N_LINES,
F_GET_READ_N_LINES,
F_SET_POSITION,
F_SET_SOURCE_UDP_MAC,
F_GET_SOURCE_UDP_MAC,
F_SET_SOURCE_UDP_MAC2,
F_GET_SOURCE_UDP_MAC2,
F_SET_SOURCE_UDP_IP,
F_GET_SOURCE_UDP_IP,
F_SET_SOURCE_UDP_IP2,
F_GET_SOURCE_UDP_IP2,
F_SET_DEST_UDP_MAC,
F_GET_DEST_UDP_MAC,
F_SET_DEST_UDP_MAC2,
F_GET_DEST_UDP_MAC2,
F_SET_DEST_UDP_IP,
F_GET_DEST_UDP_IP,
F_SET_DEST_UDP_IP2,
F_GET_DEST_UDP_IP2,
F_SET_DEST_UDP_PORT,
F_GET_DEST_UDP_PORT,
F_SET_DEST_UDP_PORT2,
F_GET_DEST_UDP_PORT2,
F_SET_NUM_INTERFACES,
F_GET_NUM_INTERFACES,
F_SET_INTERFACE_SEL,
F_GET_INTERFACE_SEL,
F_SET_PARALLEL_MODE,
F_GET_PARALLEL_MODE,
F_SET_OVERFLOW_MODE,
F_GET_OVERFLOW_MODE,
F_SET_STOREINRAM_MODE,
F_GET_STOREINRAM_MODE,
F_SET_READOUT_MODE,
F_GET_READOUT_MODE,
F_SET_CLOCK_FREQUENCY,
F_GET_CLOCK_FREQUENCY,
F_SET_CLOCK_PHASE,
F_GET_CLOCK_PHASE,
F_GET_MAX_CLOCK_PHASE_SHIFT,
F_SET_CLOCK_DIVIDER,
F_GET_CLOCK_DIVIDER,
F_SET_PIPELINE,
F_GET_PIPELINE,
F_SET_ON_CHIP_DAC,
F_GET_ON_CHIP_DAC,
F_SET_INJECT_CHANNEL,
F_GET_INJECT_CHANNEL,
F_SET_VETO_PHOTON,
F_GET_VETO_PHOTON,
F_SET_VETO_REFERENCE,
F_GET_BURST_MODE,
F_SET_BURST_MODE,
F_SET_ADC_ENABLE_MASK_10G,
F_GET_ADC_ENABLE_MASK_10G,
F_SET_COUNTER_MASK,
F_GET_COUNTER_MASK,
F_GET_NUM_BURSTS,
F_SET_NUM_BURSTS,
F_GET_BURST_PERIOD,
F_SET_BURST_PERIOD,
F_GET_CURRENT_SOURCE,
F_SET_CURRENT_SOURCE,
F_GET_TIMING_SOURCE,
F_SET_TIMING_SOURCE,
F_GET_NUM_CHANNELS,
F_UPDATE_RATE_CORRECTION,
F_GET_RECEIVER_PARAMETERS,
NUM_DET_FUNCTIONS, F_EXEC_RECEIVER_COMMAND,
RECEIVER_ENUM_START = 256, /**< detector function should not exceed this (detector server should not compile anyway) */ F_EXIT_RECEIVER,
F_LOCK_RECEIVER,
F_GET_LAST_RECEIVER_CLIENT_IP,
F_SET_RECEIVER_PORT,
F_GET_RECEIVER_VERSION,
F_RECEIVER_SET_ROI,
F_RECEIVER_SET_NUM_FRAMES,
F_SET_RECEIVER_NUM_TRIGGERS,
F_SET_RECEIVER_NUM_BURSTS,
F_SET_RECEIVER_NUM_ADD_STORAGE_CELLS,
F_SET_RECEIVER_TIMING_MODE,
F_SET_RECEIVER_BURST_MODE,
F_RECEIVER_SET_NUM_ANALOG_SAMPLES,
F_RECEIVER_SET_NUM_DIGITAL_SAMPLES,
F_RECEIVER_SET_EXPTIME,
F_RECEIVER_SET_PERIOD,
F_RECEIVER_SET_SUB_EXPTIME,
F_RECEIVER_SET_SUB_DEADTIME,
F_SET_RECEIVER_DYNAMIC_RANGE,
F_SET_RECEIVER_STREAMING_FREQUENCY,
F_GET_RECEIVER_STREAMING_FREQUENCY,
F_GET_RECEIVER_STATUS,
F_START_RECEIVER,
F_STOP_RECEIVER,
F_SET_RECEIVER_FILE_PATH,
F_GET_RECEIVER_FILE_PATH,
F_SET_RECEIVER_FILE_NAME,
F_GET_RECEIVER_FILE_NAME,
F_SET_RECEIVER_FILE_INDEX,
F_GET_RECEIVER_FILE_INDEX,
F_GET_RECEIVER_FRAME_INDEX,
F_GET_RECEIVER_FRAMES_CAUGHT,
F_GET_NUM_MISSING_PACKETS,
F_SET_RECEIVER_FILE_WRITE,
F_GET_RECEIVER_FILE_WRITE,
F_SET_RECEIVER_MASTER_FILE_WRITE,
F_GET_RECEIVER_MASTER_FILE_WRITE,
F_SET_RECEIVER_OVERWRITE,
F_GET_RECEIVER_OVERWRITE,
F_ENABLE_RECEIVER_TEN_GIGA,
F_SET_RECEIVER_FIFO_DEPTH,
F_RECEIVER_ACTIVATE,
F_SET_RECEIVER_STREAMING,
F_GET_RECEIVER_STREAMING,
F_RECEIVER_STREAMING_TIMER,
F_SET_FLIPPED_DATA_RECEIVER,
F_SET_RECEIVER_FILE_FORMAT,
F_GET_RECEIVER_FILE_FORMAT,
F_SET_RECEIVER_STREAMING_PORT,
F_GET_RECEIVER_STREAMING_PORT,
F_SET_RECEIVER_STREAMING_SRC_IP,
F_GET_RECEIVER_STREAMING_SRC_IP,
F_SET_RECEIVER_SILENT_MODE,
F_GET_RECEIVER_SILENT_MODE,
F_RESTREAM_STOP_FROM_RECEIVER,
F_SET_ADDITIONAL_JSON_HEADER,
F_GET_ADDITIONAL_JSON_HEADER,
F_RECEIVER_UDP_SOCK_BUF_SIZE,
F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE,
F_SET_RECEIVER_FRAMES_PER_FILE,
F_GET_RECEIVER_FRAMES_PER_FILE,
F_RECEIVER_CHECK_VERSION,
F_SET_RECEIVER_DISCARD_POLICY,
F_GET_RECEIVER_DISCARD_POLICY,
F_SET_RECEIVER_PADDING,
F_GET_RECEIVER_PADDING,
F_SET_RECEIVER_DEACTIVATED_PADDING,
F_GET_RECEIVER_DEACTIVATED_PADDING,
F_RECEIVER_SET_READOUT_MODE,
F_RECEIVER_SET_ADC_MASK,
F_SET_RECEIVER_DBIT_LIST,
F_GET_RECEIVER_DBIT_LIST,
F_SET_RECEIVER_DBIT_OFFSET,
F_GET_RECEIVER_DBIT_OFFSET,
F_SET_RECEIVER_QUAD,
F_SET_RECEIVER_READ_N_LINES,
F_SET_RECEIVER_UDP_IP,
F_SET_RECEIVER_UDP_IP2,
F_SET_RECEIVER_UDP_PORT,
F_SET_RECEIVER_UDP_PORT2,
F_SET_RECEIVER_NUM_INTERFACES,
F_RECEIVER_SET_ADC_MASK_10G,
F_RECEIVER_SET_NUM_COUNTERS,
F_INCREMENT_FILE_INDEX,
F_SET_ADDITIONAL_JSON_PARAMETER,
F_GET_ADDITIONAL_JSON_PARAMETER,
F_GET_RECEIVER_PROGRESS,
F_SETUP_RECEIVER,
F_EXEC_RECEIVER_COMMAND, NUM_REC_FUNCTIONS
F_EXIT_RECEIVER,
F_LOCK_RECEIVER,
F_GET_LAST_RECEIVER_CLIENT_IP,
F_SET_RECEIVER_PORT,
F_GET_RECEIVER_VERSION,
F_RECEIVER_SET_ROI,
F_RECEIVER_SET_NUM_FRAMES,
F_SET_RECEIVER_NUM_TRIGGERS,
F_SET_RECEIVER_NUM_BURSTS,
F_SET_RECEIVER_NUM_ADD_STORAGE_CELLS,
F_SET_RECEIVER_TIMING_MODE,
F_SET_RECEIVER_BURST_MODE,
F_RECEIVER_SET_NUM_ANALOG_SAMPLES,
F_RECEIVER_SET_NUM_DIGITAL_SAMPLES,
F_RECEIVER_SET_EXPTIME,
F_RECEIVER_SET_PERIOD,
F_RECEIVER_SET_SUB_EXPTIME,
F_RECEIVER_SET_SUB_DEADTIME,
F_SET_RECEIVER_DYNAMIC_RANGE,
F_SET_RECEIVER_STREAMING_FREQUENCY,
F_GET_RECEIVER_STREAMING_FREQUENCY,
F_GET_RECEIVER_STATUS,
F_START_RECEIVER,
F_STOP_RECEIVER,
F_SET_RECEIVER_FILE_PATH,
F_GET_RECEIVER_FILE_PATH,
F_SET_RECEIVER_FILE_NAME,
F_GET_RECEIVER_FILE_NAME,
F_SET_RECEIVER_FILE_INDEX,
F_GET_RECEIVER_FILE_INDEX,
F_GET_RECEIVER_FRAME_INDEX,
F_GET_RECEIVER_FRAMES_CAUGHT,
F_GET_NUM_MISSING_PACKETS,
F_SET_RECEIVER_FILE_WRITE,
F_GET_RECEIVER_FILE_WRITE,
F_SET_RECEIVER_MASTER_FILE_WRITE,
F_GET_RECEIVER_MASTER_FILE_WRITE,
F_SET_RECEIVER_OVERWRITE,
F_GET_RECEIVER_OVERWRITE,
F_ENABLE_RECEIVER_TEN_GIGA,
F_SET_RECEIVER_FIFO_DEPTH,
F_RECEIVER_ACTIVATE,
F_SET_RECEIVER_STREAMING,
F_GET_RECEIVER_STREAMING,
F_RECEIVER_STREAMING_TIMER,
F_SET_FLIPPED_DATA_RECEIVER,
F_SET_RECEIVER_FILE_FORMAT,
F_GET_RECEIVER_FILE_FORMAT,
F_SET_RECEIVER_STREAMING_PORT,
F_GET_RECEIVER_STREAMING_PORT,
F_SET_RECEIVER_STREAMING_SRC_IP,
F_GET_RECEIVER_STREAMING_SRC_IP,
F_SET_RECEIVER_SILENT_MODE,
F_GET_RECEIVER_SILENT_MODE,
F_RESTREAM_STOP_FROM_RECEIVER,
F_SET_ADDITIONAL_JSON_HEADER,
F_GET_ADDITIONAL_JSON_HEADER,
F_RECEIVER_UDP_SOCK_BUF_SIZE,
F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE,
F_SET_RECEIVER_FRAMES_PER_FILE,
F_GET_RECEIVER_FRAMES_PER_FILE,
F_RECEIVER_CHECK_VERSION,
F_SET_RECEIVER_DISCARD_POLICY,
F_GET_RECEIVER_DISCARD_POLICY,
F_SET_RECEIVER_PADDING,
F_GET_RECEIVER_PADDING,
F_SET_RECEIVER_DEACTIVATED_PADDING,
F_GET_RECEIVER_DEACTIVATED_PADDING,
F_RECEIVER_SET_READOUT_MODE,
F_RECEIVER_SET_ADC_MASK,
F_SET_RECEIVER_DBIT_LIST,
F_GET_RECEIVER_DBIT_LIST,
F_SET_RECEIVER_DBIT_OFFSET,
F_GET_RECEIVER_DBIT_OFFSET,
F_SET_RECEIVER_QUAD,
F_SET_RECEIVER_READ_N_LINES,
F_SET_RECEIVER_UDP_IP,
F_SET_RECEIVER_UDP_IP2,
F_SET_RECEIVER_UDP_PORT,
F_SET_RECEIVER_UDP_PORT2,
F_SET_RECEIVER_NUM_INTERFACES,
F_RECEIVER_SET_ADC_MASK_10G,
F_RECEIVER_SET_NUM_COUNTERS,
F_INCREMENT_FILE_INDEX,
F_SET_ADDITIONAL_JSON_PARAMETER,
F_GET_ADDITIONAL_JSON_PARAMETER,
F_GET_RECEIVER_PROGRESS,
F_SETUP_RECEIVER,
NUM_REC_FUNCTIONS
}; };
// clang-format off
#ifdef __cplusplus #ifdef __cplusplus
static const char* getFunctionNameFromEnum(enum detFuncs func) { static const char* getFunctionNameFromEnum(enum detFuncs func) {
switch (func) { switch (func) {
@ -586,3 +587,4 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
}; };
#endif #endif
// clang-format on

18
slsSupportLib/include/versionAPI.h
View File

@ -1,13 +1,13 @@
/** API versions */ /** API versions */
#define GITBRANCH "setrxhostname" #define GITBRANCH "setrxhostname"
#define APILIB 0x200409 #define APILIB 0x200409
#define APIRECEIVER 0x200409 #define APIRECEIVER 0x200409
#define APIGUI 0x200409 #define APIGUI 0x200409
#define APIEIGER 0x200409 #define APIEIGER 0x200409
#define APICTB 0x200409 #define APICTB 0x200409
#define APIGOTTHARD 0x200409 #define APIGOTTHARD 0x200409
#define APIJUNGFRAU 0x200409 #define APIJUNGFRAU 0x200409
#define APIMYTHEN3 0x200428 #define APIMYTHEN3 0x200428
#define APIGOTTHARD2 0x200429 #define APIGOTTHARD2 0x200429
#define APIMOENCH 0x200429 #define APIMOENCH 0x200429

2
slsSupportLib/src/ClientSocket.cpp Executable file → Normal file
View File

@ -72,7 +72,7 @@ void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) {
try { try {
Receive(&ret, sizeof(ret)); Receive(&ret, sizeof(ret));
} }
// debugging // debugging
catch (sls::SocketError &e) { catch (sls::SocketError &e) {
if (socketType == "Receiver") { if (socketType == "Receiver") {

4
slsSupportLib/src/DataSocket.cpp Executable file → Normal file
View File

@ -136,8 +136,6 @@ void DataSocket::shutDownSocket() {
close(); close();
} }
void DataSocket::shutdown(){ void DataSocket::shutdown() { ::shutdown(sockfd_, SHUT_RDWR); }
::shutdown(sockfd_, SHUT_RDWR);
}
} // namespace sls } // namespace sls

4
slsSupportLib/src/ServerInterface.cpp
View File

@ -5,7 +5,7 @@
namespace sls { namespace sls {
int ServerInterface::sendResult(int ret, void *retval, int retvalSize, int ServerInterface::sendResult(int ret, void *retval, int retvalSize,
char *mess) { char *mess) {
write(&ret, sizeof(ret)); write(&ret, sizeof(ret));
if (ret == defs::FAIL) { if (ret == defs::FAIL) {
@ -13,7 +13,7 @@ int ServerInterface::sendResult(int ret, void *retval, int retvalSize,
write(mess, MAX_STR_LENGTH); write(mess, MAX_STR_LENGTH);
} else { } else {
LOG(logERROR) << "No error message provided for this " LOG(logERROR) << "No error message provided for this "
"failure. Will mess up TCP\n"; "failure. Will mess up TCP\n";
} }
} else { } else {
write(retval, retvalSize); write(retval, retvalSize);

11
slsSupportLib/src/ServerSocket.cpp Executable file → Normal file
View File

@ -1,5 +1,5 @@
#include "ServerInterface.h"
#include "ServerSocket.h" #include "ServerSocket.h"
#include "ServerInterface.h"
#include "DataSocket.h" #include "DataSocket.h"
#include "logger.h" #include "logger.h"
@ -13,8 +13,8 @@
#include <stdexcept> #include <stdexcept>
#include <unistd.h> #include <unistd.h>
#define DEFAULT_PACKET_SIZE 1286 #define DEFAULT_PACKET_SIZE 1286
#define SOCKET_BUFFER_SIZE (100 * 1024 * 1024) // 100 MB #define SOCKET_BUFFER_SIZE (100 * 1024 * 1024) // 100 MB
#define DEFAULT_BACKLOG 5 #define DEFAULT_BACKLOG 5
namespace sls { namespace sls {
@ -29,7 +29,8 @@ ServerSocket::ServerSocket(int port)
if (bind(getSocketId(), (struct sockaddr *)&serverAddr, if (bind(getSocketId(), (struct sockaddr *)&serverAddr,
sizeof(serverAddr)) != 0) { sizeof(serverAddr)) != 0) {
close(); close();
throw sls::SocketError("Server ERROR: cannot bind socket. Please check if another instance is running."); throw sls::SocketError("Server ERROR: cannot bind socket. Please check "
"if another instance is running.");
} }
if (listen(getSocketId(), DEFAULT_BACKLOG) != 0) { if (listen(getSocketId(), DEFAULT_BACKLOG) != 0) {
close(); close();
@ -38,7 +39,7 @@ ServerSocket::ServerSocket(int port)
} }
ServerInterface ServerSocket::accept() { ServerInterface ServerSocket::accept() {
lastClient = thisClient; //update from previous connection lastClient = thisClient; // update from previous connection
struct sockaddr_in clientAddr; struct sockaddr_in clientAddr;
socklen_t addr_size = sizeof clientAddr; socklen_t addr_size = sizeof clientAddr;
int newSocket = int newSocket =

1
slsSupportLib/src/ToString.cpp
View File

@ -403,7 +403,6 @@ template <> defs::burstMode StringTo(const std::string &s) {
throw sls::RuntimeError("Unknown burst mode " + s); throw sls::RuntimeError("Unknown burst mode " + s);
} }
template <> defs::timingSourceType StringTo(const std::string &s) { template <> defs::timingSourceType StringTo(const std::string &s) {
if (s == "internal") if (s == "internal")
return defs::TIMING_INTERNAL; return defs::TIMING_INTERNAL;

27
slsSupportLib/src/UdpRxSocket.cpp
View File

@ -56,22 +56,21 @@ UdpRxSocket::UdpRxSocket(int port, ssize_t packet_size, const char *hostname,
UdpRxSocket::~UdpRxSocket() { Shutdown(); } UdpRxSocket::~UdpRxSocket() { Shutdown(); }
ssize_t UdpRxSocket::getPacketSize() const noexcept { return packet_size_; } ssize_t UdpRxSocket::getPacketSize() const noexcept { return packet_size_; }
bool UdpRxSocket::ReceivePacket(char *dst) noexcept{ bool UdpRxSocket::ReceivePacket(char *dst) noexcept {
auto bytes_received = auto bytes_received =
recvfrom(sockfd_, dst, packet_size_, 0, nullptr, nullptr); recvfrom(sockfd_, dst, packet_size_, 0, nullptr, nullptr);
return bytes_received == packet_size_; return bytes_received == packet_size_;
} }
ssize_t UdpRxSocket::ReceiveDataOnly(char *dst) noexcept { ssize_t UdpRxSocket::ReceiveDataOnly(char *dst) noexcept {
auto r = recvfrom(sockfd_, dst, packet_size_, 0, nullptr, nullptr); auto r = recvfrom(sockfd_, dst, packet_size_, 0, nullptr, nullptr);
constexpr ssize_t eiger_header_packet = constexpr ssize_t eiger_header_packet = 40; // only detector that has this
40; // only detector that has this if (r == eiger_header_packet) {
if (r == eiger_header_packet) { LOG(logWARNING) << "Got header pkg";
LOG(logWARNING) << "Got header pkg"; r = recvfrom(sockfd_, dst, packet_size_, 0, nullptr, nullptr);
r = recvfrom(sockfd_, dst, packet_size_, 0, nullptr, nullptr);
}
return r;
} }
return r;
}
size_t UdpRxSocket::getBufferSize() const { size_t UdpRxSocket::getBufferSize() const {
size_t ret = 0; size_t ret = 0;
@ -87,10 +86,10 @@ void UdpRxSocket::setBufferSize(ssize_t size) {
} }
void UdpRxSocket::Shutdown() { void UdpRxSocket::Shutdown() {
shutdown(sockfd_, SHUT_RDWR); shutdown(sockfd_, SHUT_RDWR);
if (sockfd_ >= 0) { if (sockfd_ >= 0) {
close(sockfd_); close(sockfd_);
sockfd_ = -1; sockfd_ = -1;
}
} }
}
} // namespace sls } // namespace sls

68
slsSupportLib/src/ZmqSocket.cpp
View File

@ -1,12 +1,12 @@
#include "ZmqSocket.h" #include "ZmqSocket.h"
#include <zmq.h>
#include <vector>
#include <arpa/inet.h> //inet_ntoa #include <arpa/inet.h> //inet_ntoa
#include <errno.h> #include <errno.h>
#include <iostream> #include <iostream>
#include <netdb.h> //gethostbyname() #include <netdb.h> //gethostbyname()
#include <string.h> #include <string.h>
#include <unistd.h> //usleep in some machines #include <unistd.h> //usleep in some machines
#include <vector>
#include <zmq.h>
using namespace rapidjson; using namespace rapidjson;
ZmqSocket::ZmqSocket(const char *const hostname_or_ip, ZmqSocket::ZmqSocket(const char *const hostname_or_ip,
@ -145,8 +145,7 @@ int ZmqSocket::ConvertInternetAddresstoIpString(struct addrinfo *res, char *ip,
return 1; return 1;
} }
int ZmqSocket::SendHeader( int ZmqSocket::SendHeader(int index, zmqHeader header) {
int index, zmqHeader header) {
/** Json Header Format */ /** Json Header Format */
const char jsonHeaderFormat[] = "{" const char jsonHeaderFormat[] = "{"
@ -183,44 +182,25 @@ int ZmqSocket::SendHeader(
; //"}\n"; ; //"}\n";
char buf[MAX_STR_LENGTH] = ""; char buf[MAX_STR_LENGTH] = "";
sprintf(buf, jsonHeaderFormat, sprintf(buf, jsonHeaderFormat, header.jsonversion, header.dynamicRange,
header.jsonversion, header.fileIndex, header.ndetx, header.ndety, header.npixelsx,
header.dynamicRange, header.npixelsy, header.imageSize, header.acqIndex,
header.fileIndex, header.frameIndex, header.progress, header.fname.c_str(),
header.ndetx, header.data ? 1 : 0, header.completeImage ? 1 : 0,
header.ndety,
header.npixelsx,
header.npixelsy,
header.imageSize,
header.acqIndex,
header.frameIndex,
header.progress,
header.fname.c_str(),
header.data ? 1 : 0,
header.completeImage ? 1 : 0,
header.frameNumber, header.frameNumber, header.expLength, header.packetNumber,
header.expLength, header.bunchId, header.timestamp, header.modId, header.row,
header.packetNumber, header.column, header.reserved, header.debug, header.roundRNumber,
header.bunchId, header.detType, header.version,
header.timestamp,
header.modId,
header.row,
header.column,
header.reserved,
header.debug,
header.roundRNumber,
header.detType,
header.version,
// additional stuff // additional stuff
header.flippedDataX, header.flippedDataX, header.quad);
header.quad);
if (header.addJsonHeader.size() > 0) { if (header.addJsonHeader.size() > 0) {
strcat(buf, ", "); strcat(buf, ", ");
strcat(buf, "\"addJsonHeader\": {"); strcat(buf, "\"addJsonHeader\": {");
for (auto it = header.addJsonHeader.begin(); it != header.addJsonHeader.end(); ++it) { for (auto it = header.addJsonHeader.begin();
it != header.addJsonHeader.end(); ++it) {
if (it != header.addJsonHeader.begin()) { if (it != header.addJsonHeader.begin()) {
strcat(buf, ", "); strcat(buf, ", ");
} }
@ -260,7 +240,7 @@ int ZmqSocket::SendData(char *buf, int length) {
return 1; return 1;
} }
int ZmqSocket::ReceiveHeader(const int index, zmqHeader& zHeader, int ZmqSocket::ReceiveHeader(const int index, zmqHeader &zHeader,
uint32_t version) { uint32_t version) {
std::vector<char> buffer(MAX_STR_LENGTH); std::vector<char> buffer(MAX_STR_LENGTH);
int len = int len =
@ -292,7 +272,7 @@ int ZmqSocket::ReceiveHeader(const int index, zmqHeader& zHeader,
}; };
int ZmqSocket::ParseHeader(const int index, int length, char *buff, int ZmqSocket::ParseHeader(const int index, int length, char *buff,
zmqHeader& zHeader, uint32_t version) { zmqHeader &zHeader, uint32_t version) {
Document document; Document document;
if (document.Parse(buff, length).HasParseError()) { if (document.Parse(buff, length).HasParseError()) {
LOG(logERROR) << index << " Could not parse. len:" << length LOG(logERROR) << index << " Could not parse. len:" << length
@ -318,7 +298,7 @@ int ZmqSocket::ParseHeader(const int index, int length, char *buff,
// parse // parse
zHeader.data = ((document["data"].GetUint()) == 0) ? false : true; zHeader.data = ((document["data"].GetUint()) == 0) ? false : true;
zHeader.dynamicRange = document["bitmode"].GetUint(); zHeader.dynamicRange = document["bitmode"].GetUint();
zHeader.fileIndex = document["fileIndex"].GetUint64(); zHeader.fileIndex = document["fileIndex"].GetUint64();
zHeader.ndetx = document["detshape"][0].GetUint(); zHeader.ndetx = document["detshape"][0].GetUint();
zHeader.ndety = document["detshape"][1].GetUint(); zHeader.ndety = document["detshape"][1].GetUint();
zHeader.npixelsx = document["shape"][0].GetUint(); zHeader.npixelsx = document["shape"][0].GetUint();
@ -348,10 +328,12 @@ int ZmqSocket::ParseHeader(const int index, int length, char *buff,
zHeader.completeImage = document["completeImage"].GetUint(); zHeader.completeImage = document["completeImage"].GetUint();
if (document.HasMember("addJsonHeader")) { if (document.HasMember("addJsonHeader")) {
const Value& V = document["addJsonHeader"]; const Value &V = document["addJsonHeader"];
zHeader.addJsonHeader.clear(); zHeader.addJsonHeader.clear();
for (Value::ConstMemberIterator iter = V.MemberBegin(); iter != V.MemberEnd(); ++iter){ for (Value::ConstMemberIterator iter = V.MemberBegin();
zHeader.addJsonHeader[iter->name.GetString()] = iter->value.GetString(); iter != V.MemberEnd(); ++iter) {
zHeader.addJsonHeader[iter->name.GetString()] =
iter->value.GetString();
} }
} }
@ -451,7 +433,7 @@ void ZmqSocket::PrintError() {
} }
} }
//Nested class to do RAII handling of socket descriptors // Nested class to do RAII handling of socket descriptors
ZmqSocket::mySocketDescriptors::mySocketDescriptors() ZmqSocket::mySocketDescriptors::mySocketDescriptors()
: server(false), contextDescriptor(0), socketDescriptor(0){}; : server(false), contextDescriptor(0), socketDescriptor(0){};
ZmqSocket::mySocketDescriptors::~mySocketDescriptors() { ZmqSocket::mySocketDescriptors::~mySocketDescriptors() {

128
slsSupportLib/src/file_utils.cpp Executable file → Normal file
View File

@ -2,85 +2,79 @@
#include "logger.h" #include "logger.h"
#include "sls_detector_exceptions.h" #include "sls_detector_exceptions.h"
#include <errno.h>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <errno.h>
int readDataFile(std::ifstream &infile, short int *data, int nch, int offset) { int readDataFile(std::ifstream &infile, short int *data, int nch, int offset) {
int ichan, iline=0; int ichan, iline = 0;
short int idata; short int idata;
int interrupt=0; int interrupt = 0;
std::string str; std::string str;
while (infile.good() and interrupt==0) { while (infile.good() and interrupt == 0) {
getline(infile,str); getline(infile, str);
std::istringstream ssstr(str); std::istringstream ssstr(str);
ssstr >> ichan >> idata; ssstr >> ichan >> idata;
if (ssstr.fail() || ssstr.bad()) { if (ssstr.fail() || ssstr.bad()) {
interrupt=1; interrupt = 1;
break; break;
} }
if (iline<nch) { if (iline < nch) {
if (ichan>=offset) { if (ichan >= offset) {
data[iline]=idata; data[iline] = idata;
iline++; iline++;
} }
} else { } else {
interrupt=1; interrupt = 1;
break; break;
} }
return iline; return iline;
}; };
return iline; return iline;
} }
int readDataFile(std::string fname, short int *data, int nch) { int readDataFile(std::string fname, short int *data, int nch) {
std::ifstream infile; std::ifstream infile;
int iline=0; int iline = 0;
std::string str; std::string str;
infile.open(fname.c_str(), std::ios_base::in); infile.open(fname.c_str(), std::ios_base::in);
if (infile.is_open()) { if (infile.is_open()) {
iline=readDataFile(infile, data, nch, 0); iline = readDataFile(infile, data, nch, 0);
infile.close(); infile.close();
} else { } else {
LOG(logERROR) << "Could not read file " << fname; LOG(logERROR) << "Could not read file " << fname;
return -1; return -1;
} }
return iline; return iline;
} }
int writeDataFile(std::ofstream &outfile, int nch, short int *data,
int offset) {
int writeDataFile(std::ofstream &outfile,int nch, short int *data, int offset) { if (data == nullptr)
if (data==nullptr) return slsDetectorDefs::FAIL;
return slsDetectorDefs::FAIL; for (int ichan = 0; ichan < nch; ichan++)
for (int ichan=0; ichan<nch; ichan++) outfile << ichan + offset << " " << *(data + ichan) << std::endl;
outfile << ichan+offset << " " << *(data+ichan) << std::endl; return slsDetectorDefs::OK;
return slsDetectorDefs::OK;
} }
int writeDataFile(std::string fname, int nch, short int *data) {
int writeDataFile(std::string fname,int nch, short int *data) { std::ofstream outfile;
std::ofstream outfile; if (data == nullptr)
if (data==nullptr) return slsDetectorDefs::FAIL;
return slsDetectorDefs::FAIL; outfile.open(fname.c_str(), std::ios_base::out);
outfile.open (fname.c_str(),std::ios_base::out); if (outfile.is_open()) {
if (outfile.is_open()) { writeDataFile(outfile, nch, data, 0);
writeDataFile(outfile, nch, data, 0); outfile.close();
outfile.close(); return slsDetectorDefs::OK;
return slsDetectorDefs::OK; } else {
} else { LOG(logERROR) << "Could not open file " << fname << "for writing";
LOG(logERROR) << "Could not open file " << fname << "for writing"; return slsDetectorDefs::FAIL;
return slsDetectorDefs::FAIL; }
}
} }
void mkdir_p(const std::string &path, std::string dir) {
void mkdir_p(const std::string& path, std::string dir) {
if (path.length() == 0) if (path.length() == 0)
return; return;
@ -90,7 +84,7 @@ void mkdir_p(const std::string& path, std::string dir) {
if (path[i] == '/') if (path[i] == '/')
break; break;
} }
if(mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0){ if (mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) {
if (errno != EEXIST) if (errno != EEXIST)
throw sls::RuntimeError("Could not create: " + dir); throw sls::RuntimeError("Could not create: " + dir);
} }
@ -98,7 +92,3 @@ void mkdir_p(const std::string& path, std::string dir) {
if (i + 1 < path.length()) if (i + 1 < path.length())
mkdir_p(path.substr(i + 1), dir); mkdir_p(path.substr(i + 1), dir);
} }

7
slsSupportLib/src/network_utils.cpp Executable file → Normal file
View File

@ -1,5 +1,6 @@
#include "sls_detector_exceptions.h" #include "sls_detector_exceptions.h"
#include "network_utils.h"
#include <algorithm> #include <algorithm>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <cassert> #include <cassert>
@ -15,7 +16,6 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include "network_utils.h"
namespace sls { namespace sls {
@ -85,7 +85,8 @@ IpAddr HostnameToIp(const char *hostname) {
hints.ai_socktype = SOCK_STREAM; hints.ai_socktype = SOCK_STREAM;
if (getaddrinfo(hostname, nullptr, &hints, &result)) { if (getaddrinfo(hostname, nullptr, &hints, &result)) {
freeaddrinfo(result); freeaddrinfo(result);
throw RuntimeError("Could not convert hostname (" + std::string(hostname) + ") to ip"); throw RuntimeError("Could not convert hostname (" +
std::string(hostname) + ") to ip");
} }
uint32_t ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr; uint32_t ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
freeaddrinfo(result); freeaddrinfo(result);
@ -133,7 +134,7 @@ IpAddr InterfaceNameToIp(const std::string &ifn) {
continue; continue;
auto s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, auto s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host,
NI_MAXHOST, NULL, 0, NI_NUMERICHOST); NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
if ((strcmp(ifa->ifa_name, ifn.c_str()) == 0) && if ((strcmp(ifa->ifa_name, ifn.c_str()) == 0) &&
(ifa->ifa_addr->sa_family == AF_INET)) { (ifa->ifa_addr->sa_family == AF_INET)) {

23
slsSupportLib/tests/test-FixedCapacityContainer.cpp
View File

@ -10,19 +10,18 @@ TEST_CASE("FixedCapacityContainer is a container") {
REQUIRE(sls::is_container<FixedCapacityContainer<int, 7>>::value == true); REQUIRE(sls::is_container<FixedCapacityContainer<int, 7>>::value == true);
} }
TEST_CASE("Comparing FixedCapacity containers"){ TEST_CASE("Comparing FixedCapacity containers") {
FixedCapacityContainer<int, 5> a{0,1,2}; FixedCapacityContainer<int, 5> a{0, 1, 2};
FixedCapacityContainer<int, 5> b{0,1,2}; FixedCapacityContainer<int, 5> b{0, 1, 2};
FixedCapacityContainer<int, 5> c{0,1,2,4}; FixedCapacityContainer<int, 5> c{0, 1, 2, 4};
REQUIRE(a==b);
REQUIRE_FALSE(a!=b);
REQUIRE_FALSE(a==c);
REQUIRE(a!=c);
REQUIRE(c!=a);
REQUIRE_FALSE(c==a);
REQUIRE_FALSE(b==c);
REQUIRE(a == b);
REQUIRE_FALSE(a != b);
REQUIRE_FALSE(a == c);
REQUIRE(a != c);
REQUIRE(c != a);
REQUIRE_FALSE(c == a);
REQUIRE_FALSE(b == c);
} }
TEST_CASE("Compare array and fixed capacity container") { TEST_CASE("Compare array and fixed capacity container") {

8
slsSupportLib/tests/test-Sockets.cpp
View File

@ -13,7 +13,7 @@ std::vector<char> server() {
s.Receive(buffer.data(), buffer.size()); s.Receive(buffer.data(), buffer.size());
std::cout << "ServerReceived: " << std::string(buffer.begin(), buffer.end()) std::cout << "ServerReceived: " << std::string(buffer.begin(), buffer.end())
<< '\n'; << '\n';
std::vector<char> to_send(100, '\0'); std::vector<char> to_send(100, '\0');
to_send[0] = 'O'; to_send[0] = 'O';
to_send[1] = 'K'; to_send[1] = 'K';
@ -27,7 +27,7 @@ TEST_CASE("The server recive the same message as we send", "[support]") {
std::vector<char> sent_message(100, '\0'); std::vector<char> sent_message(100, '\0');
const char m[]{"some message"}; const char m[]{"some message"};
std::copy(std::begin(m), std::end(m), sent_message.data()); std::copy(std::begin(m), std::end(m), sent_message.data());
auto s = std::async(std::launch::async, server); auto s = std::async(std::launch::async, server);
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
auto client = sls::DetectorSocket("localhost", 1950); auto client = sls::DetectorSocket("localhost", 1950);
@ -37,10 +37,10 @@ TEST_CASE("The server recive the same message as we send", "[support]") {
auto server_message = s.get(); auto server_message = s.get();
CHECK(server_message == sent_message); CHECK(server_message == sent_message);
CHECK(std::string(received_message.data()) == "OK" ); CHECK(std::string(received_message.data()) == "OK");
CHECK(client.getSocketId() == -1); CHECK(client.getSocketId() == -1);
} }
TEST_CASE("throws on no server", "[support]"){ TEST_CASE("throws on no server", "[support]") {
CHECK_THROWS(sls::DetectorSocket("localhost", 1950)); CHECK_THROWS(sls::DetectorSocket("localhost", 1950));
} }

44
slsSupportLib/tests/test-ToString.cpp
View File

@ -1,16 +1,16 @@
#include "TimeHelper.h" #include "TimeHelper.h"
#include "ToString.h" #include "ToString.h"
#include "catch.hpp"
#include "network_utils.h" #include "network_utils.h"
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
#include "catch.hpp"
#include <array> #include <array>
#include <map> #include <map>
#include <vector> #include <vector>
// using namespace sls; // using namespace sls;
using sls::defs;
using sls::StringTo; using sls::StringTo;
using sls::ToString; using sls::ToString;
using sls::defs;
using namespace sls::time; using namespace sls::time;
TEST_CASE("Integer conversions", "[support]") { TEST_CASE("Integer conversions", "[support]") {
@ -45,7 +45,6 @@ TEST_CASE("conversion from duration to string", "[support]") {
REQUIRE(ToString(us(-100)) == "-100us"); REQUIRE(ToString(us(-100)) == "-100us");
} }
TEST_CASE("Convert vector of time", "[support]") { TEST_CASE("Convert vector of time", "[support]") {
std::vector<ns> vec{ns(150), us(10), ns(600)}; std::vector<ns> vec{ns(150), us(10), ns(600)};
REQUIRE(ToString(vec) == "[150ns, 10us, 600ns]"); REQUIRE(ToString(vec) == "[150ns, 10us, 600ns]");
@ -85,27 +84,26 @@ TEST_CASE("Array") {
REQUIRE(ToString(arr) == "[1, 2, 3]"); REQUIRE(ToString(arr) == "[1, 2, 3]");
} }
TEST_CASE("Convert types with str method"){ TEST_CASE("Convert types with str method") {
sls::IpAddr addr; sls::IpAddr addr;
REQUIRE(ToString(addr) == "0.0.0.0"); REQUIRE(ToString(addr) == "0.0.0.0");
REQUIRE(ToString(sls::IpAddr{}) == "0.0.0.0"); REQUIRE(ToString(sls::IpAddr{}) == "0.0.0.0");
} }
TEST_CASE("String to string", "[support]"){ TEST_CASE("String to string", "[support]") {
std::string s = "hej"; std::string s = "hej";
REQUIRE(ToString(s) == "hej"); REQUIRE(ToString(s) == "hej");
} }
TEST_CASE("vector of strings"){ TEST_CASE("vector of strings") {
std::vector<std::string> vec{"5", "s"}; std::vector<std::string> vec{"5", "s"};
REQUIRE(ToString(vec) == "[5, s]"); REQUIRE(ToString(vec) == "[5, s]");
std::vector<std::string> vec2{"some", "strange", "words", "75"}; std::vector<std::string> vec2{"some", "strange", "words", "75"};
REQUIRE(ToString(vec2) == "[some, strange, words, 75]"); REQUIRE(ToString(vec2) == "[some, strange, words, 75]");
} }
TEST_CASE("run status"){ TEST_CASE("run status") {
using defs = slsDetectorDefs; using defs = slsDetectorDefs;
REQUIRE(ToString(defs::runStatus::ERROR) == "error"); REQUIRE(ToString(defs::runStatus::ERROR) == "error");
REQUIRE(ToString(defs::runStatus::WAITING) == "waiting"); REQUIRE(ToString(defs::runStatus::WAITING) == "waiting");
@ -126,7 +124,7 @@ TEST_CASE("string to std::chrono::duration", "[support]") {
REQUIRE_THROWS(StringTo<ns>("asvn")); REQUIRE_THROWS(StringTo<ns>("asvn"));
} }
TEST_CASE("string to detectorType"){ TEST_CASE("string to detectorType") {
using dt = slsDetectorDefs::detectorType; using dt = slsDetectorDefs::detectorType;
REQUIRE(StringTo<dt>("Eiger") == dt::EIGER); REQUIRE(StringTo<dt>("Eiger") == dt::EIGER);
REQUIRE(StringTo<dt>("Gotthard") == dt::GOTTHARD); REQUIRE(StringTo<dt>("Gotthard") == dt::GOTTHARD);
@ -137,14 +135,13 @@ TEST_CASE("string to detectorType"){
REQUIRE(StringTo<dt>("Gotthard2") == dt::GOTTHARD2); REQUIRE(StringTo<dt>("Gotthard2") == dt::GOTTHARD2);
} }
TEST_CASE("vec"){ TEST_CASE("vec") {
using rs = slsDetectorDefs::runStatus; using rs = slsDetectorDefs::runStatus;
std::vector<rs> vec{rs::ERROR, rs::IDLE}; std::vector<rs> vec{rs::ERROR, rs::IDLE};
REQUIRE(ToString(vec) == "[error, idle]"); REQUIRE(ToString(vec) == "[error, idle]");
} }
TEST_CASE("uint32 from string") {
TEST_CASE("uint32 from string"){
REQUIRE(StringTo<uint32_t>("0") == 0); REQUIRE(StringTo<uint32_t>("0") == 0);
REQUIRE(StringTo<uint32_t>("5") == 5u); REQUIRE(StringTo<uint32_t>("5") == 5u);
REQUIRE(StringTo<uint32_t>("16") == 16u); REQUIRE(StringTo<uint32_t>("16") == 16u);
@ -153,10 +150,9 @@ TEST_CASE("uint32 from string"){
REQUIRE(StringTo<uint32_t>("0x15") == 21u); REQUIRE(StringTo<uint32_t>("0x15") == 21u);
REQUIRE(StringTo<uint32_t>("0x15") == 0x15); REQUIRE(StringTo<uint32_t>("0x15") == 0x15);
REQUIRE(StringTo<uint32_t>("0xffffff") == 0xffffff); REQUIRE(StringTo<uint32_t>("0xffffff") == 0xffffff);
} }
TEST_CASE("uint64 from string"){ TEST_CASE("uint64 from string") {
REQUIRE(StringTo<uint64_t>("0") == 0); REQUIRE(StringTo<uint64_t>("0") == 0);
REQUIRE(StringTo<uint64_t>("5") == 5u); REQUIRE(StringTo<uint64_t>("5") == 5u);
REQUIRE(StringTo<uint64_t>("16") == 16u); REQUIRE(StringTo<uint64_t>("16") == 16u);
@ -164,11 +160,9 @@ TEST_CASE("uint64 from string"){
REQUIRE(StringTo<uint64_t>("0x14") == 20u); REQUIRE(StringTo<uint64_t>("0x14") == 20u);
REQUIRE(StringTo<uint64_t>("0x15") == 21u); REQUIRE(StringTo<uint64_t>("0x15") == 21u);
REQUIRE(StringTo<uint64_t>("0xffffff") == 0xffffff); REQUIRE(StringTo<uint64_t>("0xffffff") == 0xffffff);
} }
TEST_CASE("int from string") {
TEST_CASE("int from string"){
REQUIRE(StringTo<int>("-1") == -1); REQUIRE(StringTo<int>("-1") == -1);
REQUIRE(StringTo<int>("-0x1") == -0x1); REQUIRE(StringTo<int>("-0x1") == -0x1);
REQUIRE(StringTo<int>("-0x1") == -1); REQUIRE(StringTo<int>("-0x1") == -1);
@ -179,11 +173,9 @@ TEST_CASE("int from string"){
REQUIRE(StringTo<int>("0x14") == 20); REQUIRE(StringTo<int>("0x14") == 20);
REQUIRE(StringTo<int>("0x15") == 21); REQUIRE(StringTo<int>("0x15") == 21);
REQUIRE(StringTo<int>("0xffffff") == 0xffffff); REQUIRE(StringTo<int>("0xffffff") == 0xffffff);
} }
TEST_CASE("int64_t from string") {
TEST_CASE("int64_t from string"){
REQUIRE(StringTo<int64_t>("-1") == -1); REQUIRE(StringTo<int64_t>("-1") == -1);
REQUIRE(StringTo<int64_t>("-0x1") == -0x1); REQUIRE(StringTo<int64_t>("-0x1") == -0x1);
REQUIRE(StringTo<int64_t>("-0x1") == -1); REQUIRE(StringTo<int64_t>("-0x1") == -1);
@ -194,11 +186,9 @@ TEST_CASE("int64_t from string"){
REQUIRE(StringTo<int64_t>("0x14") == 20); REQUIRE(StringTo<int64_t>("0x14") == 20);
REQUIRE(StringTo<int64_t>("0x15") == 21); REQUIRE(StringTo<int64_t>("0x15") == 21);
REQUIRE(StringTo<int64_t>("0xffffff") == 0xffffff); REQUIRE(StringTo<int64_t>("0xffffff") == 0xffffff);
} }
TEST_CASE("std::map of strings") {
TEST_CASE("std::map of strings"){
std::map<std::string, std::string> m; std::map<std::string, std::string> m;
m["key"] = "value"; m["key"] = "value";
auto s = ToString(m); auto s = ToString(m);
@ -209,10 +199,9 @@ TEST_CASE("std::map of strings"){
m["test"] = "tree"; m["test"] = "tree";
REQUIRE(ToString(m) == "{chrusi: musi, key: value, test: tree}"); REQUIRE(ToString(m) == "{chrusi: musi, key: value, test: tree}");
} }
TEST_CASE("std::map of ints"){ TEST_CASE("std::map of ints") {
std::map<int, int> m; std::map<int, int> m;
m[5] = 10; m[5] = 10;
@ -221,10 +210,9 @@ TEST_CASE("std::map of ints"){
REQUIRE(ToString(m) == "{5: 10, 500: 50}"); REQUIRE(ToString(m) == "{5: 10, 500: 50}");
m[372] = 999; m[372] = 999;
REQUIRE(ToString(m) == "{5: 10, 372: 999, 500: 50}"); REQUIRE(ToString(m) == "{5: 10, 372: 999, 500: 50}");
} }
TEST_CASE("Detector type"){ TEST_CASE("Detector type") {
auto dt = defs::detectorType::EIGER; auto dt = defs::detectorType::EIGER;
REQUIRE(ToString(dt) == "Eiger"); REQUIRE(ToString(dt) == "Eiger");
REQUIRE(StringTo<defs::detectorType>("Eiger") == dt); REQUIRE(StringTo<defs::detectorType>("Eiger") == dt);

14
slsSupportLib/tests/test-TypeTraits.cpp
View File

@ -1,12 +1,12 @@
#include "TypeTraits.h" #include "TypeTraits.h"
#include "catch.hpp" #include "catch.hpp"
#include <array> #include <array>
#include <vector>
#include <sstream>
#include <chrono> #include <chrono>
#include <initializer_list> #include <initializer_list>
#include <sstream>
#include <vector>
//Dummy classes only used here for testing // Dummy classes only used here for testing
class DummyWithStr { class DummyWithStr {
public: public:
std::string str(); std::string str();
@ -32,7 +32,7 @@ TEST_CASE("Check for str() on ostream") {
REQUIRE(sls::has_str<std::ostringstream>::value == true); REQUIRE(sls::has_str<std::ostringstream>::value == true);
} }
TEST_CASE("sls::is_duration"){ TEST_CASE("sls::is_duration") {
REQUIRE(sls::is_duration<std::chrono::nanoseconds>::value == true); REQUIRE(sls::is_duration<std::chrono::nanoseconds>::value == true);
REQUIRE(sls::is_duration<std::chrono::seconds>::value == true); REQUIRE(sls::is_duration<std::chrono::seconds>::value == true);
REQUIRE(sls::is_duration<std::chrono::hours>::value == true); REQUIRE(sls::is_duration<std::chrono::hours>::value == true);
@ -41,11 +41,11 @@ TEST_CASE("sls::is_duration"){
REQUIRE(sls::is_duration<std::vector<int>>::value == false); REQUIRE(sls::is_duration<std::vector<int>>::value == false);
} }
TEST_CASE("initializer list"){ TEST_CASE("initializer list") {
REQUIRE(sls::is_light_container<std::initializer_list<int>>::value == true); REQUIRE(sls::is_light_container<std::initializer_list<int>>::value == true);
} }
TEST_CASE("Check for emplace back"){ TEST_CASE("Check for emplace back") {
//we know vector should have this its the type trait that is tested // we know vector should have this its the type trait that is tested
REQUIRE(sls::has_emplace_back<std::vector<int>>::value == true); REQUIRE(sls::has_emplace_back<std::vector<int>>::value == true);
} }

15
slsSupportLib/tests/test-UdpRxSocket.cpp
View File

@ -1,17 +1,17 @@
#include "UdpRxSocket.h" #include "UdpRxSocket.h"
#include "catch.hpp" #include "catch.hpp"
#include "sls_detector_exceptions.h" #include "sls_detector_exceptions.h"
#include <future>
#include <thread>
#include <vector>
#include <cstdint> #include <cstdint>
#include <errno.h> #include <errno.h>
#include <future>
#include <iostream> #include <iostream>
#include <netdb.h> #include <netdb.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <string.h> #include <string.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <thread>
#include <unistd.h> #include <unistd.h>
#include <vector>
constexpr int default_port = 50001; constexpr int default_port = 50001;
@ -44,7 +44,7 @@ int open_socket(int port) {
return fd; return fd;
} }
TEST_CASE("Get packet size returns the packet size we set in the constructor"){ TEST_CASE("Get packet size returns the packet size we set in the constructor") {
constexpr int port = 50001; constexpr int port = 50001;
constexpr ssize_t packet_size = 8000; constexpr ssize_t packet_size = 8000;
sls::UdpRxSocket s{port, packet_size}; sls::UdpRxSocket s{port, packet_size};
@ -57,17 +57,16 @@ TEST_CASE("Receive data from a vector") {
std::vector<int> data_received(data_to_send.size()); std::vector<int> data_received(data_to_send.size());
ssize_t packet_size = ssize_t packet_size =
sizeof(decltype(data_to_send)::value_type) * data_to_send.size(); sizeof(decltype(data_to_send)::value_type) * data_to_send.size();
sls::UdpRxSocket udpsock{port, packet_size}; sls::UdpRxSocket udpsock{port, packet_size};
int fd = open_socket(port); int fd = open_socket(port);
auto n = write(fd, data_to_send.data(), packet_size); auto n = write(fd, data_to_send.data(), packet_size);
CHECK(n == packet_size); CHECK(n == packet_size);
CHECK(udpsock.ReceivePacket((char*)data_received.data())); CHECK(udpsock.ReceivePacket((char *)data_received.data()));
close(fd); close(fd);
CHECK(data_to_send == data_received); CHECK(data_to_send == data_received);
} }
TEST_CASE("Shutdown socket without hanging when waiting for data") { TEST_CASE("Shutdown socket without hanging when waiting for data") {

12
slsSupportLib/tests/test-container_utils.cpp Executable file → Normal file
View File

@ -113,8 +113,7 @@ TEST_CASE("Compare a vector containing two vectors", "[support]") {
CHECK(minusOneIfDifferent(d) == d[2]); CHECK(minusOneIfDifferent(d) == d[2]);
} }
TEST_CASE("vector of bool", "[support]") {
TEST_CASE("vector of bool", "[support]"){
std::vector<bool> a{true, true, true}; std::vector<bool> a{true, true, true};
std::vector<bool> b{false, false, false}; std::vector<bool> b{false, false, false};
std::vector<bool> c{true, false, true}; std::vector<bool> c{true, false, true};
@ -124,14 +123,13 @@ TEST_CASE("vector of bool", "[support]"){
CHECK(minusOneIfDifferent(c) == -1); CHECK(minusOneIfDifferent(c) == -1);
} }
TEST_CASE("compare a vector of arrays", "[support]"){ TEST_CASE("compare a vector of arrays", "[support]") {
std::vector<std::array<uint64_t, 3>> vec0{{5,6,8},{5,6,8},{5,6,8}}; std::vector<std::array<uint64_t, 3>> vec0{{5, 6, 8}, {5, 6, 8}, {5, 6, 8}};
CHECK(minusOneIfDifferent(vec0) == std::array<uint64_t, 3>{5,6,8}); CHECK(minusOneIfDifferent(vec0) == std::array<uint64_t, 3>{5, 6, 8});
std::array<uint64_t, 3> arr; std::array<uint64_t, 3> arr;
arr.fill(-1); arr.fill(-1);
std::vector<std::array<uint64_t, 3>> vec1{{5,90,8},{5,6,8},{5,6,8}}; std::vector<std::array<uint64_t, 3>> vec1{{5, 90, 8}, {5, 6, 8}, {5, 6, 8}};
CHECK(minusOneIfDifferent(vec1) == arr); CHECK(minusOneIfDifferent(vec1) == arr);
} }

18
slsSupportLib/tests/test-logger.cpp
View File

@ -1,8 +1,8 @@
#include "catch.hpp" #include "catch.hpp"
#include "logger.h" #include "logger.h"
#include <iostream>
#include <fstream>
#include <chrono> #include <chrono>
#include <fstream>
#include <iostream>
using sls::Logger; using sls::Logger;
@ -27,25 +27,23 @@ TEST_CASE("Test output") {
Logger::ReportingLevel() = logERROR; Logger::ReportingLevel() = logERROR;
//Redirect std::clog to local buffer // Redirect std::clog to local buffer
std::ostringstream local; std::ostringstream local;
auto clog_buff = std::clog.rdbuf(); auto clog_buff = std::clog.rdbuf();
std::clog.rdbuf(local.rdbuf()); std::clog.rdbuf(local.rdbuf());
//Try printing something with too low level // Try printing something with too low level
LOG(logDEBUG) << "This should not be printed"; LOG(logDEBUG) << "This should not be printed";
CHECK(local.str().empty()); CHECK(local.str().empty());
//Try printing something with a higher level // Try printing something with a higher level
LOG(logERROR) << "This should be printed"; LOG(logERROR) << "This should be printed";
CHECK(!local.str().empty()); CHECK(!local.str().empty());
std::clog.rdbuf(clog_buff); // restore std::clog.rdbuf(clog_buff); // restore
Logger::ReportingLevel() = old_value; //reset Logger::ReportingLevel() = old_value; // reset
// Check that the message is in the printed string
//Check that the message is in the printed string
auto r = local.str(); auto r = local.str();
auto pos = r.find("This should be printed"); auto pos = r.find("This should be printed");
CHECK(pos != std::string::npos); CHECK(pos != std::string::npos);
} }

2
slsSupportLib/tests/test-network_utils.cpp Executable file → Normal file
View File

@ -105,7 +105,7 @@ TEST_CASE("MAC Output operator gives same result as string", "[support]") {
CHECK(os.str() == addr.str()); CHECK(os.str() == addr.str());
} }
TEST_CASE("Copy construct a MacAddr"){ TEST_CASE("Copy construct a MacAddr") {
MacAddr addr{"00:50:c2:46:d9:a6"}; MacAddr addr{"00:50:c2:46:d9:a6"};
MacAddr addr2(addr); MacAddr addr2(addr);
CHECK(addr == addr2); CHECK(addr == addr2);

129
slsSupportLib/tests/test-string_utils.cpp Executable file → Normal file
View File

@ -5,107 +5,102 @@
#include "string_utils.h" #include "string_utils.h"
TEST_CASE("copy a string") { TEST_CASE("copy a string") {
char src[10] = "hej"; char src[10] = "hej";
REQUIRE(src[3]=='\0'); REQUIRE(src[3] == '\0');
char dst[20]; char dst[20];
sls::strcpy_safe(dst, src); sls::strcpy_safe(dst, src);
REQUIRE(dst[0]=='h'); REQUIRE(dst[0] == 'h');
REQUIRE(dst[1]=='e'); REQUIRE(dst[1] == 'e');
REQUIRE(dst[2]=='j'); REQUIRE(dst[2] == 'j');
REQUIRE(dst[3]=='\0'); REQUIRE(dst[3] == '\0');
} }
#ifdef NDEBUG #ifdef NDEBUG
//This test can only run in release since we assert on the length of the string // This test can only run in release since we assert on the length of the string
TEST_CASE("copy a long string"){ TEST_CASE("copy a long string") {
auto src = "some very very long sting that does not fit"; auto src = "some very very long sting that does not fit";
char dst[3]; char dst[3];
sls::strcpy_safe(dst, src); sls::strcpy_safe(dst, src);
REQUIRE(dst[0]=='s'); REQUIRE(dst[0] == 's');
REQUIRE(dst[1]=='o'); REQUIRE(dst[1] == 'o');
REQUIRE(dst[2]=='\0'); REQUIRE(dst[2] == '\0');
} }
#endif #endif
TEST_CASE("Concat") { TEST_CASE("Concat") {
std::vector<std::string> v{"one", "one", "one"}; std::vector<std::string> v{"one", "one", "one"};
std::vector<std::string> v2{"one", "one", "one"}; std::vector<std::string> v2{"one", "one", "one"};
auto r = sls::concatenateIfDifferent(v); auto r = sls::concatenateIfDifferent(v);
REQUIRE(r == std::string("one")); REQUIRE(r == std::string("one"));
r.clear(); r.clear();
// make sure we didn't modify the string // make sure we didn't modify the string
REQUIRE(v == v2); REQUIRE(v == v2);
SECTION("add a different value"){ SECTION("add a different value") {
v.emplace_back("two"); v.emplace_back("two");
REQUIRE(v!=v2); REQUIRE(v != v2);
REQUIRE( sls::concatenateIfDifferent(v) == "one+one+one+two+"); REQUIRE(sls::concatenateIfDifferent(v) == "one+one+one+two+");
} }
} }
TEST_CASE("split a string with end delimiter"){ TEST_CASE("split a string with end delimiter") {
std::string s("abra+kadabra+"); std::string s("abra+kadabra+");
auto r =sls::split(s, '+'); auto r = sls::split(s, '+');
REQUIRE(r.size()==2); REQUIRE(r.size() == 2);
REQUIRE(r[0]=="abra"); REQUIRE(r[0] == "abra");
REQUIRE(r[1]=="kadabra"); REQUIRE(r[1] == "kadabra");
} }
TEST_CASE("split a string without end delimiter"){ TEST_CASE("split a string without end delimiter") {
std::string s("abra+kadabra+filibom"); std::string s("abra+kadabra+filibom");
auto r =sls::split(s, '+'); auto r = sls::split(s, '+');
REQUIRE(r.size()==3); REQUIRE(r.size() == 3);
REQUIRE(r[0]=="abra"); REQUIRE(r[0] == "abra");
REQUIRE(r[1]=="kadabra"); REQUIRE(r[1] == "kadabra");
REQUIRE(r[2]=="filibom"); REQUIRE(r[2] == "filibom");
} }
TEST_CASE("concatenate non empty strings"){ TEST_CASE("concatenate non empty strings") {
std::vector<std::string> vec{"hej", "kalas", "", "foto"}; std::vector<std::string> vec{"hej", "kalas", "", "foto"};
REQUIRE(vec.size()==4); REQUIRE(vec.size() == 4);
auto ret = sls::concatenateNonEmptyStrings(vec); auto ret = sls::concatenateNonEmptyStrings(vec);
REQUIRE(ret == "hej+kalas+foto+"); REQUIRE(ret == "hej+kalas+foto+");
} }
TEST_CASE("concatenate non empty strings with only emty"){ TEST_CASE("concatenate non empty strings with only emty") {
std::vector<std::string> vec{"", "", ""}; std::vector<std::string> vec{"", "", ""};
REQUIRE(vec.size()==3); REQUIRE(vec.size() == 3);
auto ret = sls::concatenateNonEmptyStrings(vec); auto ret = sls::concatenateNonEmptyStrings(vec);
REQUIRE(ret.empty()); REQUIRE(ret.empty());
} }
TEST_CASE("concatenate non empty strings with one element"){ TEST_CASE("concatenate non empty strings with one element") {
std::vector<std::string> vec{"", "hej", "", "", ""}; std::vector<std::string> vec{"", "hej", "", "", ""};
REQUIRE(vec.size()==5); REQUIRE(vec.size() == 5);
auto ret = sls::concatenateNonEmptyStrings(vec); auto ret = sls::concatenateNonEmptyStrings(vec);
REQUIRE(ret=="hej+"); REQUIRE(ret == "hej+");
} }
TEST_CASE("Remove char from string") {
TEST_CASE("Remove char from string"){ char str[] = "sometest";
char str[] = "sometest"; sls::removeChar(str, 'e');
sls::removeChar(str, 'e'); REQUIRE(std::string(str) == "somtst");
REQUIRE(std::string(str) == "somtst");
} }
TEST_CASE("Remove char from empty string"){ TEST_CASE("Remove char from empty string") {
char str[50] = {}; char str[50] = {};
sls::removeChar(str, 'e'); sls::removeChar(str, 'e');
REQUIRE(std::string(str) == ""); REQUIRE(std::string(str) == "");
} }
TEST_CASE("Many characters in a row"){ TEST_CASE("Many characters in a row") {
char str[] = "someeequitellll::ongstring"; char str[] = "someeequitellll::ongstring";
sls::removeChar(str, 'l'); sls::removeChar(str, 'l');
REQUIRE(std::string(str) == "someeequite::ongstring"); REQUIRE(std::string(str) == "someeequite::ongstring");
} }
// TEST_CASE("concat things not being strings") // TEST_CASE("concat things not being strings")