detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-13 05:17:13 +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

3
slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
View File

@ -242,4 +242,5 @@ int validate_udp_configuration(int);
int get_bursts_left(int); int get_bursts_left(int);
int start_readout(int); int start_readout(int);
int set_default_dacs(int); int set_default_dacs(int);
int is_virtual(int); int is_virtual(int);
int get_pattern(int);

251
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -361,6 +361,7 @@ void function_table() {
flist[F_START_READOUT] = &start_readout; flist[F_START_READOUT] = &start_readout;
flist[F_SET_DEFAULT_DACS] = &set_default_dacs; flist[F_SET_DEFAULT_DACS] = &set_default_dacs;
flist[F_IS_VIRTUAL] = &is_virtual; flist[F_IS_VIRTUAL] = &is_virtual;
flist[F_GET_PATTERN] = &get_pattern;
// check // check
if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) { if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@ -7534,14 +7535,18 @@ int set_pattern(int file_des) {
patternParameters *pat = malloc(sizeof(patternParameters)); patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters)); memset(pat, 0, sizeof(patternParameters));
if (receiveDataOnly(file_des, pat, sizeof(patternParameters)) < 0) // ignoring endianness for eiger
if (receiveData(file_des, pat, sizeof(patternParameters), INT32) < 0) {
if (pat != NULL)
free(pat);
return printSocketReadError(); return printSocketReadError();
}
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD) && !defined(MYTHEN3D) #if !defined(CHIPTESTBOARDD) && !defined(MOENCHD) && !defined(MYTHEN3D)
functionNotImplemented(); functionNotImplemented();
#else #else
if (Server_VerifyLock() == OK) { if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Setting Pattern from file\n")); LOG(logINFO, ("Setting Pattern from structure\n"));
LOG(logINFO, LOG(logINFO,
("Setting Pattern Word (printing every 10 words that are not 0\n")); ("Setting Pattern Word (printing every 10 words that are not 0\n"));
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) { for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
@ -7551,95 +7556,191 @@ int set_pattern(int file_des) {
} }
writePatternWord(i, pat->word[i]); writePatternWord(i, pat->word[i]);
} }
int numLoops = -1, retval0 = -1, retval1 = -1;
uint64_t retval64 = -1;
#ifndef MYTHEN3D #ifndef MYTHEN3D
if (ret == OK) { if (ret == OK) {
retval64 = writePatternIOControl(pat->patioctrl); uint64_t retval64 = writePatternIOControl(pat->ioctrl);
validate64(pat->patioctrl, retval64, "set pattern IO Control", HEX); validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX);
} }
#endif #endif
if (ret == OK) { if (ret == OK) {
numLoops = -1; int numLoops = -1;
retval0 = pat->patlimits[0]; int retval0 = pat->limits[0];
retval1 = pat->patlimits[1]; int retval1 = pat->limits[1];
setPatternLoop(-1, &retval0, &retval1, &numLoops); setPatternLoop(-1, &retval0, &retval1, &numLoops);
validate(pat->patlimits[0], retval0, validate(pat->limits[0], retval0,
"set pattern Limits start address", HEX); "set pattern Limits start address", HEX);
validate(pat->patlimits[1], retval1, validate(pat->limits[1], retval1,
"set pattern Limits start address", HEX); "set pattern Limits start address", HEX);
} }
if (ret == OK) { if (ret == OK) {
retval0 = pat->patloop[0]; for (int i = 0; i <= 2; ++i) {
retval1 = pat->patloop[1]; char msg[128];
numLoops = pat->patnloop[0]; int retval0 = -1, retval1 = -1, numLoops = -1;
setPatternLoop(0, &retval0, &retval1, &numLoops); uint64_t retval64 = -1;
validate(pat->patloop[0], retval0,
"set pattern Loop 0 start address", HEX); // patloop
validate(pat->patloop[1], retval1, retval0 = pat->loop[i * 2 + 0];
"set pattern Loop 0 stop address", HEX); retval1 = pat->loop[i * 2 + 1];
validate(pat->patnloop[0], numLoops, "set pattern Loop 0 num loops", numLoops = pat->nloop[i];
HEX); setPatternLoop(i, &retval0, &retval1, &numLoops);
} memset(msg, 0, sizeof(msg));
if (ret == OK) { sprintf(msg, "set pattern Loop %d start address", i);
retval0 = pat->patloop[2]; validate(pat->loop[i * 2 + 0], retval0, msg, HEX);
retval1 = pat->patloop[3]; if (ret == FAIL) {
numLoops = pat->patnloop[1]; break;
setPatternLoop(1, &retval0, &retval1, &numLoops); }
validate(pat->patloop[2], retval0, memset(msg, 0, sizeof(msg));
"set pattern Loop 1 start address", HEX); sprintf(msg, "set pattern Loop %d stop address", i);
validate(pat->patloop[3], retval1, validate(pat->loop[i * 2 + 1], retval1, msg, HEX);
"set pattern Loop 1 stop address", HEX); if (ret == FAIL) {
validate(pat->patnloop[1], numLoops, "set pattern Loop 1 num loops", break;
HEX); }
} memset(msg, 0, sizeof(msg));
if (ret == OK) { sprintf(msg, "set pattern Loop %d num loops", i);
retval0 = pat->patloop[4]; validate(pat->nloop[i], numLoops, msg, HEX);
retval1 = pat->patloop[5]; if (ret == FAIL) {
numLoops = pat->patnloop[2]; break;
setPatternLoop(2, &retval0, &retval1, &numLoops); }
validate(pat->patloop[4], retval0,
"set pattern Loop 2 start address", HEX); // patwait
validate(pat->patloop[5], retval1, memset(msg, 0, sizeof(msg));
"set pattern Loop 2 stop address", HEX); sprintf(msg, "set pattern Loop %d wait address", i);
validate(pat->patnloop[2], numLoops, "set pattern Loop 2 num loops", retval0 = setPatternWaitAddress(i, pat->wait[i]);
HEX); validate(pat->wait[i], retval0, msg, HEX);
} if (ret == FAIL) {
if (ret == OK) { break;
retval0 = setPatternWaitAddress(0, pat->patwait[0]); }
validate(pat->patwait[0], retval0,
"set pattern Loop 0 wait address", HEX); // patwaittime
} memset(msg, 0, sizeof(msg));
if (ret == OK) { sprintf(msg, "set pattern Loop %d wait time", i);
retval0 = setPatternWaitAddress(1, pat->patwait[1]); retval64 = setPatternWaitTime(i, pat->waittime[i]);
validate(pat->patwait[1], retval0, validate64(pat->waittime[i], retval64, msg, HEX);
"set pattern Loop 1 wait address", HEX); if (ret == FAIL) {
} break;
if (ret == OK) { }
retval0 = setPatternWaitAddress(2, pat->patwait[2]); }
validate(pat->patwait[2], retval0,
"set pattern Loop 2 wait address", HEX);
}
if (ret == OK) {
uint64_t retval64 = setPatternWaitTime(0, pat->patwaittime[0]);
validate64(pat->patwaittime[0], retval64,
"set pattern Loop 0 wait time", HEX);
}
if (ret == OK) {
retval64 = setPatternWaitTime(1, pat->patwaittime[1]);
validate64(pat->patwaittime[1], retval64,
"set pattern Loop 1 wait time", HEX);
}
if (ret == OK) {
retval64 = setPatternWaitTime(2, pat->patwaittime[2]);
validate64(pat->patwaittime[2], retval64,
"set pattern Loop 2 wait time", HEX);
} }
} }
#endif #endif
if (pat != NULL)
free(pat);
return Server_SendResult(file_des, INT32, NULL, 0); return Server_SendResult(file_des, INT32, NULL, 0);
} }
int get_pattern(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters));
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD) && !defined(MYTHEN3D)
functionNotImplemented();
#else
if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Getting Pattern from structure\n"));
// patword
LOG(logDEBUG,
("retval pattern word (printing every 10 words that are not 0\n"));
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
int retval = readPatternWord(i);
if (retval == -1) {
ret = FAIL;
sprintf(mess, "could not read pattern word for address 0x%x\n",
i);
LOG(logERROR, (mess));
break;
}
pat->word[i] = retval;
// debug print
if ((i % 10 == 0) && pat->word[i] != 0) {
LOG(logDEBUG,
("retval Patpattern word (addr:0x%x, word:0x%llx)\n", i,
(long long int)pat->word[i]));
}
}
// patioctrl
#ifndef MYTHEN3D
if (ret == OK) {
pat->ioctrl = writePatternIOControl(-1);
LOG(logDEBUG, ("retval pattern io control:0x%llx\n",
(long long int)pat->ioctrl));
}
#endif
if (ret == OK) {
// patlimits
int numLoops = -1;
int retval0 = -1;
int retval1 = -1;
setPatternLoop(-1, &retval0, &retval1, &numLoops);
pat->limits[0] = retval0;
pat->limits[1] = retval1;
LOG(logDEBUG, ("retval pattern limits start:0x%x stop:0x%x\n",
pat->limits[0], pat->limits[1]));
for (int i = 0; i <= 2; ++i) {
// patloop
{
int numLoops = -1;
int retval0 = -1;
int retval1 = -1;
setPatternLoop(i, &retval0, &retval1, &numLoops);
pat->nloop[i] = numLoops;
pat->loop[i * 2 + 0] = retval0;
pat->loop[i * 2 + 1] = retval1;
LOG(logDEBUG, ("retval pattern loop level %d start:0x%x "
"stop:0x%x numLoops:%d\n",
i, pat->loop[i * 2 + 0],
pat->loop[i * 2 + 0], pat->nloop[i]));
}
// patwait
{
pat->wait[i] = setPatternWaitAddress(i, -1);
if ((int)pat->wait[i] == -1) {
ret = FAIL;
sprintf(mess,
"could not read pattern wait address for level "
"%d\n",
i);
LOG(logERROR, (mess));
break;
}
LOG(logDEBUG,
("retval pattern wait address for level %d: 0x%x\n", i,
pat->wait[i]));
}
// patwaittime
{
pat->waittime[i] = setPatternWaitTime(i, -1);
if ((int64_t)pat->waittime[i] == -1) {
ret = FAIL;
sprintf(
mess,
"could not read pattern wait time for level %d\n",
i);
LOG(logERROR, (mess));
break;
}
LOG(logDEBUG,
("retval pattern wait time for level %d: %lld\n", i,
(long long int)pat->waittime[i]));
}
}
}
}
#endif
// ignoring endianness for eiger
int ret =
Server_SendResult(file_des, INT32, pat, sizeof(patternParameters));
if (pat != NULL)
free(pat);
return ret;
}
int get_scan(int file_des) { int get_scan(int file_des) {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));

75
slsDetectorSoftware/src/Detector.cpp
View File

@ -1754,44 +1754,57 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
// Pattern // Pattern
void Detector::savePattern(const std::string &fname) { void Detector::savePattern(const std::string &fname) {
std::ofstream outfile; Result<std::unique_ptr<defs::patternParameters>> patlist;
outfile.open(fname.c_str(), std::ios_base::out); for (int i = 0; i < patlist.size(); ++i) {
if (!outfile.is_open()) { patlist[i] = sls::make_unique<defs::patternParameters>();
throw RuntimeError("Could not create file to save pattern");
} }
// get pattern limits Result<defs::patternParameters> pat;
auto r = pimpl->Parallel(&Module::getPatternLoopAddresses, {}, -1) = sls::make_unique<defs::patternParameters>();
.tsquash("Inconsistent pattern limits"); pimpl->Parallel(&Module::getPattern, {}, pat.get());
pat->save(fname);
CmdProxy proxy(this); /*
// pattern words std::ofstream outfile;
for (int i = r[0]; i <= r[1]; ++i) { outfile.open(fname.c_str(), std::ios_base::out);
std::ostringstream os; if (!outfile.is_open()) {
os << "0x" << std::hex << i; throw RuntimeError("Could not create file to save pattern");
auto addr = os.str(); }
proxy.Call("patword", {addr}, -1, defs::GET_ACTION, outfile); // get pattern limits
} auto r = pimpl->Parallel(&Module::getPatternLoopAddresses, {}, -1)
// rest of pattern file .tsquash("Inconsistent pattern limits");
std::vector<std::string> commands{
"patioctrl", "patlimits", "patloop0", "patnloop0", CmdProxy proxy(this);
"patloop1", "patnloop1", "patloop2", "patnloop2", // pattern words
"patwait0", "patwaittime0", "patwait1", "patwaittime1", for (int i = r[0]; i <= r[1]; ++i) {
"patwait2", "patwaittime2", "patmask", "patsetbit", std::ostringstream os;
}; os << "0x" << std::hex << i;
auto det_type = getDetectorType().squash(); auto addr = os.str();
if (det_type == defs::MYTHEN3) { proxy.Call("patword", {addr}, -1, defs::GET_ACTION, outfile);
commands.erase(commands.begin(), commands.begin() + 2); }
} // rest of pattern file
for (const auto &cmd : commands) std::vector<std::string> commands{
proxy.Call(cmd, {}, -1, defs::GET_ACTION, outfile); "patioctrl", "patlimits", "patloop0", "patnloop0",
} "patloop1", "patnloop1", "patloop2", "patnloop2",
"patwait0", "patwaittime0", "patwait1", "patwaittime1",
"patwait2", "patwaittime2", "patmask", "patsetbit",
};
auto det_type = getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
commands.erase(commands.begin(), commands.begin() + 2);
}
for (const auto &cmd : commands)
proxy.Call(cmd, {}, -1, defs::GET_ACTION, outfile);
*/
} // namespace sls
void Detector::setPattern(const std::string &fname, Positions pos) { void Detector::setPattern(const std::string &fname, Positions pos) {
pimpl->Parallel(&Module::setPattern, pos, fname); auto pat = sls::make_unique<defs::patternParameters>();
pat->load(fname);
pimpl->Parallel(&Module::setPattern, pos, pat.get());
} }
void Detector::setPattern(const defs::patternParameters *pat, Positions pos) { void Detector::setPattern(const defs::patternParameters *pat, Positions pos) {
pimpl->Parallel(&Module::setPatternStructure, pos, pat); pimpl->Parallel(&Module::setPattern, pos, pat);
} }
Result<uint64_t> Detector::getPatternIOControl(Positions pos) const { Result<uint64_t> Detector::getPatternIOControl(Positions pos) const {

35
slsDetectorSoftware/src/Module.cpp
View File

@ -1913,37 +1913,14 @@ void Module::setLEDEnable(bool enable) {
// Pattern // Pattern
void Module::setPattern(const std::string &fname) { void Module::setPattern(const defs::patternParameters *pat) {
auto pat = sls::make_unique<patternParameters>(); pat->validate();
pat->load(fname); sendToDetector(F_SET_PATTERN, pat, sizeof(patternParameters), nullptr, 0);
setPatternStructure(pat.get());
} }
void Module::setPatternStructure(const defs::patternParameters *pat) { void Module::getPattern(defs::patternParameters *pat) {
// verifications *pat = sendToDetector<defs::patternParameters>(F_GET_PATTERN);
if (pat->patlimits[0] >= MAX_PATTERN_LENGTH || pat->validate();
pat->patlimits[1] >= MAX_PATTERN_LENGTH) {
throw RuntimeError("Invalid Pattern limits address [" +
ToString(pat->patlimits[0]) + std::string(", ") +
ToString(pat->patlimits[1]) + std::string("]"));
}
for (int i = 0; i != 3; ++i) {
if (pat->patloop[i * 2 + 0] >= MAX_PATTERN_LENGTH ||
pat->patloop[i * 2 + 1] >= MAX_PATTERN_LENGTH) {
throw RuntimeError(
"Invalid Pattern loop address for level " + ToString(i) +
std::string(" [") + ToString(pat->patloop[i * 2 + 0]) +
std::string(", ") + ToString(pat->patloop[i * 2 + 1]) +
std::string("]"));
}
if (pat->patwait[i] >= MAX_PATTERN_LENGTH) {
throw RuntimeError("Invalid Pattern wait address for level " +
ToString(i) + std::string(" ") +
ToString(pat->patwait[i]));
}
}
LOG(logDEBUG1) << "Sending pattern from file to detector:" << *pat;
sendToDetector(F_SET_PATTERN, pat, sizeof(patternParameters), nullptr, 0);
} }
uint64_t Module::getPatternIOControl() const { uint64_t Module::getPatternIOControl() const {

4
slsDetectorSoftware/src/Module.h
View File

@ -462,8 +462,8 @@ class Module : public virtual slsDetectorDefs {
* Pattern * * Pattern *
* * * *
* ************************************************/ * ************************************************/
void setPattern(const std::string &fname); void setPattern(const defs::patternParameters *pat);
void setPatternStructure(const defs::patternParameters *pat); void getPattern(defs::patternParameters *pat);
uint64_t getPatternIOControl() const; uint64_t getPatternIOControl() const;
void setPatternIOControl(uint64_t word); void setPatternIOControl(uint64_t word);
uint64_t getPatternWord(int addr) const; uint64_t getPatternWord(int addr) const;

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

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

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

@ -217,6 +217,7 @@ enum detFuncs {
F_START_READOUT, F_START_READOUT,
F_SET_DEFAULT_DACS, F_SET_DEFAULT_DACS,
F_IS_VIRTUAL, F_IS_VIRTUAL,
F_GET_PATTERN,
NUM_DET_FUNCTIONS, NUM_DET_FUNCTIONS,
RECEIVER_ENUM_START = 256, /**< detector function should not exceed this 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_START_READOUT: return "F_START_READOUT";
case F_SET_DEFAULT_DACS: return "F_SET_DEFAULT_DACS"; case F_SET_DEFAULT_DACS: return "F_SET_DEFAULT_DACS";
case F_IS_VIRTUAL: return "F_IS_VIRTUAL"; 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 NUM_DET_FUNCTIONS: return "NUM_DET_FUNCTIONS";
case RECEIVER_ENUM_START: return "RECEIVER_ENUM_START"; 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; << ToStringHex(r.word[i], word_width) << std::endl;
} }
} }
oss << "patioctrl " << ToStringHex(r.patioctrl, word_width) << std::endl oss << "patioctrl " << ToStringHex(r.ioctrl, word_width) << std::endl
<< "patlimits " << ToStringHex(r.patlimits[0], addr_width) << " " << "patlimits " << ToStringHex(r.limits[0], addr_width) << " "
<< ToStringHex(r.patlimits[1], addr_width) << std::endl << ToStringHex(r.limits[1], addr_width) << std::endl
<< "patloop0 " << ToStringHex(r.patloop[0], addr_width) << " " << "patloop0 " << ToStringHex(r.loop[0], addr_width) << " "
<< ToStringHex(r.patloop[1], addr_width) << std::endl << ToStringHex(r.loop[1], addr_width) << std::endl
<< "patnloop0 " << r.patnloop[0] << std::endl << "patnloop0 " << r.nloop[0] << std::endl
<< "patloop1 " << ToStringHex(r.patloop[2], addr_width) << " " << "patloop1 " << ToStringHex(r.loop[2], addr_width) << " "
<< ToStringHex(r.patloop[3], addr_width) << std::endl << ToStringHex(r.loop[3], addr_width) << std::endl
<< "patnloop1 " << r.patnloop[1] << std::endl << "patnloop1 " << r.nloop[1] << std::endl
<< "patloop2 " << ToStringHex(r.patloop[4], addr_width) << " " << "patloop2 " << ToStringHex(r.loop[4], addr_width) << " "
<< ToStringHex(r.patloop[5], addr_width) << std::endl << ToStringHex(r.loop[5], addr_width) << std::endl
<< "patnloop2 " << r.patnloop[2] << std::endl << "patnloop2 " << r.nloop[2] << std::endl
<< "patwait0 " << ToStringHex(r.patwait[0], addr_width) << std::endl << "patwait0 " << ToStringHex(r.wait[0], addr_width) << std::endl
<< "patwaittime0 " << r.patwaittime[0] << std::endl << "patwaittime0 " << r.waittime[0] << std::endl
<< "patwait1 " << ToStringHex(r.patwait[1], addr_width) << std::endl << "patwait1 " << ToStringHex(r.wait[1], addr_width) << std::endl
<< "patwaittime1 " << r.patwaittime[1] << std::endl << "patwaittime1 " << r.waittime[1] << std::endl
<< "patwait2 " << ToStringHex(r.patwait[2], addr_width) << std::endl << "patwait2 " << ToStringHex(r.wait[2], addr_width) << std::endl
<< "patwaittime2 " << r.patwaittime[2] << std::endl << "patwaittime2 " << r.waittime[2] << std::endl
<< ']'; << ']';
return oss.str(); return oss.str();
} }

147
slsSupportLib/src/sls_detector_defs.cpp
View File

@ -1,16 +1,16 @@
#include "sls/sls_detector_defs.h" #include "sls/sls_detector_defs.h"
#include "sls/logger.h"
#include "sls/ToString.h" #include "sls/ToString.h"
#include "sls/logger.h"
#include <fstream> #include <fstream>
#include <sstream>
#include <iterator> #include <iterator>
#include <sstream>
using sls::RuntimeError; using sls::RuntimeError;
using sls::StringTo; using sls::StringTo;
using sls::ToString; using sls::ToString;
void slsDetectorDefs::patternParameters::load(const std::string& fname){ void slsDetectorDefs::patternParameters::load(const std::string &fname) {
std::ifstream input_file(fname); std::ifstream input_file(fname);
if (!input_file) { if (!input_file) {
throw RuntimeError("Could not open pattern file " + fname + throw RuntimeError("Could not open pattern file " + fname +
" for reading"); " for reading");
@ -46,14 +46,14 @@ std::ifstream input_file(fname);
throw RuntimeError("Invalid arguments for " + throw RuntimeError("Invalid arguments for " +
ToString(args)); ToString(args));
} }
patioctrl = StringTo<uint64_t>(args[1]); ioctrl = StringTo<uint64_t>(args[1]);
} else if (cmd == "patlimits") { } else if (cmd == "patlimits") {
if (nargs != 2) { if (nargs != 2) {
throw RuntimeError("Invalid arguments for " + throw RuntimeError("Invalid arguments for " +
ToString(args)); ToString(args));
} }
patlimits[0] = StringTo<uint32_t>(args[1]); limits[0] = StringTo<uint32_t>(args[1]);
patlimits[1] = StringTo<uint32_t>(args[2]); limits[1] = StringTo<uint32_t>(args[2]);
} else if (cmd == "patloop0" || cmd == "patloop1" || } else if (cmd == "patloop0" || cmd == "patloop1" ||
cmd == "patloop2") { cmd == "patloop2") {
if (nargs != 2) { if (nargs != 2) {
@ -61,10 +61,10 @@ std::ifstream input_file(fname);
ToString(args)); ToString(args));
} }
int level = cmd[cmd.find_first_of("012")] - '0'; int level = cmd[cmd.find_first_of("012")] - '0';
int patloop1 = StringTo<uint32_t>(args[1]); int loop1 = StringTo<uint32_t>(args[1]);
int patloop2 = StringTo<uint32_t>(args[2]); int loop2 = StringTo<uint32_t>(args[2]);
patloop[level * 2 + 0] = patloop1; loop[level * 2 + 0] = loop1;
patloop[level * 2 + 1] = patloop2; loop[level * 2 + 1] = loop2;
} else if (cmd == "patnloop0" || cmd == "patnloop1" || } else if (cmd == "patnloop0" || cmd == "patnloop1" ||
cmd == "patnloop2") { cmd == "patnloop2") {
if (nargs != 1) { if (nargs != 1) {
@ -72,7 +72,7 @@ std::ifstream input_file(fname);
ToString(args)); ToString(args));
} }
int level = cmd[cmd.find_first_of("012")] - '0'; 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" || } else if (cmd == "patwait0" || cmd == "patwait1" ||
cmd == "patwait2") { cmd == "patwait2") {
if (nargs != 1) { if (nargs != 1) {
@ -80,7 +80,7 @@ std::ifstream input_file(fname);
ToString(args)); ToString(args));
} }
int level = cmd[cmd.find_first_of("012")] - '0'; 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" || } else if (cmd == "patwaittime0" || cmd == "patwaittime1" ||
cmd == "patwaittime2") { cmd == "patwaittime2") {
if (nargs != 1) { if (nargs != 1) {
@ -88,10 +88,129 @@ std::ifstream input_file(fname);
ToString(args)); ToString(args));
} }
int level = cmd[cmd.find_first_of("012")] - '0'; int level = cmd[cmd.find_first_of("012")] - '0';
patwaittime[level] = StringTo<uint64_t>(args[1]); waittime[level] = StringTo<uint64_t>(args[1]);
} else { } else {
throw RuntimeError("Unknown command in pattern file " + cmd); 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]));
}
}
} }