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

WIP

Browse Source
This commit is contained in:
maliakal_d
2020-11-25 15:29:46 +01:00
parent 8bf9f974a3
commit a12dd153ef
9 changed files with 399 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
slsSupportLib/include/sls/sls_detector_defs.h
View File

@ -475,35 +475,35 @@ typedef struct {
} __attribute__((packed));
#endif
/** pattern structure */
#ifdef __cplusplus
struct patternParameters {
#else
typedef struct __attribute__((packed)){
typedef struct __attribute__((packed)) {
#endif
uint64_t word[MAX_PATTERN_LENGTH];
uint64_t patioctrl;
uint32_t patlimits[2];
uint32_t patloop[6];
uint32_t patnloop[3];
uint32_t patwait[3];
uint64_t patwaittime[3];
uint64_t ioctrl;
uint32_t limits[2];
// loop0 start, loop0 stop .. loop2 start, loop2 stop
uint32_t loop[6];
uint32_t nloop[3];
uint32_t wait[3];
uint64_t waittime[3];
#ifdef __cplusplus
public:
patternParameters(){
// Since the def has to be c compatible we can't use {} for the members
public:
patternParameters() {
// Since the def has to be c compatible we can't use {} for the
// members
memset(this, 0, sizeof(patternParameters));
}
void load(const std::string& fname);
void load(const std::string &fname);
void save(const std::string &fname);
void validate() const;
} __attribute__((packed));
#else
} patternParameters;
} patternParameters;
#endif
#ifdef __cplusplus
protected:
#endif

2
slsSupportLib/include/sls/sls_detector_funcs.h
View File

@ -217,6 +217,7 @@ enum detFuncs {
F_START_READOUT,
F_SET_DEFAULT_DACS,
F_IS_VIRTUAL,
F_GET_PATTERN,
NUM_DET_FUNCTIONS,
RECEIVER_ENUM_START = 256, /**< detector function should not exceed this
@ -539,6 +540,7 @@ const char* getFunctionNameFromEnum(enum detFuncs func) {
case F_START_READOUT: return "F_START_READOUT";
case F_SET_DEFAULT_DACS: return "F_SET_DEFAULT_DACS";
case F_IS_VIRTUAL: return "F_IS_VIRTUAL";
case F_GET_PATTERN: return "F_GET_PATTERN";
case NUM_DET_FUNCTIONS: return "NUM_DET_FUNCTIONS";
case RECEIVER_ENUM_START: return "RECEIVER_ENUM_START";

36
slsSupportLib/src/ToString.cpp
View File

@ -99,24 +99,24 @@ std::string ToString(const slsDetectorDefs::patternParameters &r) {
<< ToStringHex(r.word[i], word_width) << std::endl;
}
}
oss << "patioctrl " << ToStringHex(r.patioctrl, word_width) << std::endl
<< "patlimits " << ToStringHex(r.patlimits[0], addr_width) << " "
<< ToStringHex(r.patlimits[1], addr_width) << std::endl
<< "patloop0 " << ToStringHex(r.patloop[0], addr_width) << " "
<< ToStringHex(r.patloop[1], addr_width) << std::endl
<< "patnloop0 " << r.patnloop[0] << std::endl
<< "patloop1 " << ToStringHex(r.patloop[2], addr_width) << " "
<< ToStringHex(r.patloop[3], addr_width) << std::endl
<< "patnloop1 " << r.patnloop[1] << std::endl
<< "patloop2 " << ToStringHex(r.patloop[4], addr_width) << " "
<< ToStringHex(r.patloop[5], addr_width) << std::endl
<< "patnloop2 " << r.patnloop[2] << std::endl
<< "patwait0 " << ToStringHex(r.patwait[0], addr_width) << std::endl
<< "patwaittime0 " << r.patwaittime[0] << std::endl
<< "patwait1 " << ToStringHex(r.patwait[1], addr_width) << std::endl
<< "patwaittime1 " << r.patwaittime[1] << std::endl
<< "patwait2 " << ToStringHex(r.patwait[2], addr_width) << std::endl
<< "patwaittime2 " << r.patwaittime[2] << std::endl
oss << "patioctrl " << ToStringHex(r.ioctrl, word_width) << std::endl
<< "patlimits " << ToStringHex(r.limits[0], addr_width) << " "
<< ToStringHex(r.limits[1], addr_width) << std::endl
<< "patloop0 " << ToStringHex(r.loop[0], addr_width) << " "
<< ToStringHex(r.loop[1], addr_width) << std::endl
<< "patnloop0 " << r.nloop[0] << std::endl
<< "patloop1 " << ToStringHex(r.loop[2], addr_width) << " "
<< ToStringHex(r.loop[3], addr_width) << std::endl
<< "patnloop1 " << r.nloop[1] << std::endl
<< "patloop2 " << ToStringHex(r.loop[4], addr_width) << " "
<< ToStringHex(r.loop[5], addr_width) << std::endl
<< "patnloop2 " << r.nloop[2] << std::endl
<< "patwait0 " << ToStringHex(r.wait[0], addr_width) << std::endl
<< "patwaittime0 " << r.waittime[0] << std::endl
<< "patwait1 " << ToStringHex(r.wait[1], addr_width) << std::endl
<< "patwaittime1 " << r.waittime[1] << std::endl
<< "patwait2 " << ToStringHex(r.wait[2], addr_width) << std::endl
<< "patwaittime2 " << r.waittime[2] << std::endl
<< ']';
return oss.str();
}

147
slsSupportLib/src/sls_detector_defs.cpp
View File

@ -1,16 +1,16 @@
#include "sls/sls_detector_defs.h"
#include "sls/logger.h"
#include "sls/ToString.h"
#include "sls/logger.h"
#include <fstream>
#include <sstream>
#include <iterator>
#include <sstream>
using sls::RuntimeError;
using sls::StringTo;
using sls::ToString;
void slsDetectorDefs::patternParameters::load(const std::string& fname){
std::ifstream input_file(fname);
void slsDetectorDefs::patternParameters::load(const std::string &fname) {
std::ifstream input_file(fname);
if (!input_file) {
throw RuntimeError("Could not open pattern file " + fname +
" for reading");
@ -46,14 +46,14 @@ std::ifstream input_file(fname);
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
patioctrl = StringTo<uint64_t>(args[1]);
ioctrl = StringTo<uint64_t>(args[1]);
} else if (cmd == "patlimits") {
if (nargs != 2) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
patlimits[0] = StringTo<uint32_t>(args[1]);
patlimits[1] = StringTo<uint32_t>(args[2]);
limits[0] = StringTo<uint32_t>(args[1]);
limits[1] = StringTo<uint32_t>(args[2]);
} else if (cmd == "patloop0" || cmd == "patloop1" ||
cmd == "patloop2") {
if (nargs != 2) {
@ -61,10 +61,10 @@ std::ifstream input_file(fname);
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
int patloop1 = StringTo<uint32_t>(args[1]);
int patloop2 = StringTo<uint32_t>(args[2]);
patloop[level * 2 + 0] = patloop1;
patloop[level * 2 + 1] = patloop2;
int loop1 = StringTo<uint32_t>(args[1]);
int loop2 = StringTo<uint32_t>(args[2]);
loop[level * 2 + 0] = loop1;
loop[level * 2 + 1] = loop2;
} else if (cmd == "patnloop0" || cmd == "patnloop1" ||
cmd == "patnloop2") {
if (nargs != 1) {
@ -72,7 +72,7 @@ std::ifstream input_file(fname);
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
patnloop[level] = StringTo<uint32_t>(args[1]);
nloop[level] = StringTo<uint32_t>(args[1]);
} else if (cmd == "patwait0" || cmd == "patwait1" ||
cmd == "patwait2") {
if (nargs != 1) {
@ -80,7 +80,7 @@ std::ifstream input_file(fname);
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
patwait[level] = StringTo<uint32_t>(args[1]);
wait[level] = StringTo<uint32_t>(args[1]);
} else if (cmd == "patwaittime0" || cmd == "patwaittime1" ||
cmd == "patwaittime2") {
if (nargs != 1) {
@ -88,10 +88,129 @@ std::ifstream input_file(fname);
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
patwaittime[level] = StringTo<uint64_t>(args[1]);
waittime[level] = StringTo<uint64_t>(args[1]);
} else {
throw RuntimeError("Unknown command in pattern file " + cmd);
}
}
}
}
void slsDetectorDefs::patternParameters::save(const std::string &fname) {
std::ofstream output_file(fname);
if (!output_file) {
throw RuntimeError("Could not open pattern file " + fname +
" for writing");
}
std::ostringstream os;
// pattern word
for (uint32_t i = limits[0]; i <= limits[1]; ++i) {
output_file << "patword [" << sls::ToStringHex(i, 4) << ", "
<< sls::ToStringHex(word[i], 16) << "]" << std::endl;
}
/*
for (std::string line; std::getline(output_file, line);) {
if (line.find('#') != std::string::npos) {
line.erase(line.find('#'));
}
LOG(logDEBUG1) << "line after removing comments:\n\t" << line;
if (line.length() > 1) {
// convert command and string to a vector
std::istringstream iss(line);
auto it = std::istream_iterator<std::string>(iss);
std::vector<std::string> args = std::vector<std::string>(
it, std::istream_iterator<std::string>());
std::string cmd = args[0];
int nargs = args.size() - 1;
if (cmd == "patword") {
if (nargs != 2) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
uint32_t addr = StringTo<uint32_t>(args[1]);
if (addr >= MAX_PATTERN_LENGTH) {
throw RuntimeError("Invalid address for " +
ToString(args));
}
word[addr] = StringTo<uint64_t>(args[2]);
} else if (cmd == "patioctrl") {
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
patioctrl = StringTo<uint64_t>(args[1]);
} else if (cmd == "patlimits") {
if (nargs != 2) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
patlimits[0] = StringTo<uint32_t>(args[1]);
patlimits[1] = StringTo<uint32_t>(args[2]);
} else if (cmd == "patloop0" || cmd == "patloop1" ||
cmd == "patloop2") {
if (nargs != 2) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
int patloop1 = StringTo<uint32_t>(args[1]);
int patloop2 = StringTo<uint32_t>(args[2]);
patloop[level * 2 + 0] = patloop1;
patloop[level * 2 + 1] = patloop2;
} else if (cmd == "patnloop0" || cmd == "patnloop1" ||
cmd == "patnloop2") {
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
patnloop[level] = StringTo<uint32_t>(args[1]);
} else if (cmd == "patwait0" || cmd == "patwait1" ||
cmd == "patwait2") {
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
patwait[level] = StringTo<uint32_t>(args[1]);
} else if (cmd == "patwaittime0" || cmd == "patwaittime1" ||
cmd == "patwaittime2") {
if (nargs != 1) {
throw RuntimeError("Invalid arguments for " +
ToString(args));
}
int level = cmd[cmd.find_first_of("012")] - '0';
patwaittime[level] = StringTo<uint64_t>(args[1]);
} else {
throw RuntimeError("Unknown command in pattern file " +
cmd);
}
}
}*/
}
void slsDetectorDefs::patternParameters::validate() const {
if (limits[0] >= MAX_PATTERN_LENGTH || limits[1] >= MAX_PATTERN_LENGTH) {
throw RuntimeError("Invalid Pattern limits address [" +
ToString(limits[0]) + std::string(", ") +
ToString(limits[1]) + std::string("]"));
}
for (int i = 0; i != 3; ++i) {
if (loop[i * 2 + 0] >= MAX_PATTERN_LENGTH ||
loop[i * 2 + 1] >= MAX_PATTERN_LENGTH) {
throw RuntimeError("Invalid Pattern loop address for level " +
ToString(i) + std::string(" [") +
ToString(loop[i * 2 + 0]) + std::string(", ") +
ToString(loop[i * 2 + 1]) + std::string("]"));
}
if (wait[i] >= MAX_PATTERN_LENGTH) {
throw RuntimeError("Invalid Pattern wait address for level " +
ToString(i) + std::string(" ") +
ToString(wait[i]));
}
}
}