detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-12 04:47:14 +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 start_readout(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_SET_DEFAULT_DACS] = &set_default_dacs;
flist[F_IS_VIRTUAL] = &is_virtual;
flist[F_GET_PATTERN] = &get_pattern;
// check
if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@ -7534,14 +7535,18 @@ int set_pattern(int file_des) {
patternParameters *pat = malloc(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();
}
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD) && !defined(MYTHEN3D)
functionNotImplemented();
#else
if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Setting Pattern from file\n"));
LOG(logINFO, ("Setting Pattern from structure\n"));
LOG(logINFO,
("Setting Pattern Word (printing every 10 words that are not 0\n"));
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
@ -7551,95 +7556,191 @@ int set_pattern(int file_des) {
}
writePatternWord(i, pat->word[i]);
}
int numLoops = -1, retval0 = -1, retval1 = -1;
uint64_t retval64 = -1;
#ifndef MYTHEN3D
if (ret == OK) {
retval64 = writePatternIOControl(pat->patioctrl);
validate64(pat->patioctrl, retval64, "set pattern IO Control", HEX);
uint64_t retval64 = writePatternIOControl(pat->ioctrl);
validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX);
}
#endif
if (ret == OK) {
numLoops = -1;
retval0 = pat->patlimits[0];
retval1 = pat->patlimits[1];
int numLoops = -1;
int retval0 = pat->limits[0];
int retval1 = pat->limits[1];
setPatternLoop(-1, &retval0, &retval1, &numLoops);
validate(pat->patlimits[0], retval0,
validate(pat->limits[0], retval0,
"set pattern Limits start address", HEX);
validate(pat->patlimits[1], retval1,
validate(pat->limits[1], retval1,
"set pattern Limits start address", HEX);
}
if (ret == OK) {
retval0 = pat->patloop[0];
retval1 = pat->patloop[1];
numLoops = pat->patnloop[0];
setPatternLoop(0, &retval0, &retval1, &numLoops);
validate(pat->patloop[0], retval0,
"set pattern Loop 0 start address", HEX);
validate(pat->patloop[1], retval1,
"set pattern Loop 0 stop address", HEX);
validate(pat->patnloop[0], numLoops, "set pattern Loop 0 num loops",
HEX);
}
if (ret == OK) {
retval0 = pat->patloop[2];
retval1 = pat->patloop[3];
numLoops = pat->patnloop[1];
setPatternLoop(1, &retval0, &retval1, &numLoops);
validate(pat->patloop[2], retval0,
"set pattern Loop 1 start address", HEX);
validate(pat->patloop[3], retval1,
"set pattern Loop 1 stop address", HEX);
validate(pat->patnloop[1], numLoops, "set pattern Loop 1 num loops",
HEX);
}
if (ret == OK) {
retval0 = pat->patloop[4];
retval1 = pat->patloop[5];
numLoops = pat->patnloop[2];
setPatternLoop(2, &retval0, &retval1, &numLoops);
validate(pat->patloop[4], retval0,
"set pattern Loop 2 start address", HEX);
validate(pat->patloop[5], retval1,
"set pattern Loop 2 stop address", HEX);
validate(pat->patnloop[2], numLoops, "set pattern Loop 2 num loops",
HEX);
}
if (ret == OK) {
retval0 = setPatternWaitAddress(0, pat->patwait[0]);
validate(pat->patwait[0], retval0,
"set pattern Loop 0 wait address", HEX);
}
if (ret == OK) {
retval0 = setPatternWaitAddress(1, pat->patwait[1]);
validate(pat->patwait[1], retval0,
"set pattern Loop 1 wait address", HEX);
}
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);
for (int i = 0; i <= 2; ++i) {
char msg[128];
int retval0 = -1, retval1 = -1, numLoops = -1;
uint64_t retval64 = -1;
// patloop
retval0 = pat->loop[i * 2 + 0];
retval1 = pat->loop[i * 2 + 1];
numLoops = pat->nloop[i];
setPatternLoop(i, &retval0, &retval1, &numLoops);
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d start address", i);
validate(pat->loop[i * 2 + 0], retval0, msg, HEX);
if (ret == FAIL) {
break;
}
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d stop address", i);
validate(pat->loop[i * 2 + 1], retval1, msg, HEX);
if (ret == FAIL) {
break;
}
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d num loops", i);
validate(pat->nloop[i], numLoops, msg, HEX);
if (ret == FAIL) {
break;
}
// patwait
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait address", i);
retval0 = setPatternWaitAddress(i, pat->wait[i]);
validate(pat->wait[i], retval0, msg, HEX);
if (ret == FAIL) {
break;
}
// patwaittime
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait time", i);
retval64 = setPatternWaitTime(i, pat->waittime[i]);
validate64(pat->waittime[i], retval64, msg, HEX);
if (ret == FAIL) {
break;
}
}
}
}
#endif
if (pat != NULL)
free(pat);
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) {
ret = OK;
memset(mess, 0, sizeof(mess));

75
slsDetectorSoftware/src/Detector.cpp
View File

@ -1754,44 +1754,57 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
// Pattern
void Detector::savePattern(const std::string &fname) {
std::ofstream outfile;
outfile.open(fname.c_str(), std::ios_base::out);
if (!outfile.is_open()) {
throw RuntimeError("Could not create file to save pattern");
Result<std::unique_ptr<defs::patternParameters>> patlist;
for (int i = 0; i < patlist.size(); ++i) {
patlist[i] = sls::make_unique<defs::patternParameters>();
}
// get pattern limits
auto r = pimpl->Parallel(&Module::getPatternLoopAddresses, {}, -1)
.tsquash("Inconsistent pattern limits");
Result<defs::patternParameters> pat;
= sls::make_unique<defs::patternParameters>();
pimpl->Parallel(&Module::getPattern, {}, pat.get());
pat->save(fname);
CmdProxy proxy(this);
// pattern words
for (int i = r[0]; i <= r[1]; ++i) {
std::ostringstream os;
os << "0x" << std::hex << i;
auto addr = os.str();
proxy.Call("patword", {addr}, -1, defs::GET_ACTION, outfile);
}
// rest of pattern file
std::vector<std::string> commands{
"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);
}
/*
std::ofstream outfile;
outfile.open(fname.c_str(), std::ios_base::out);
if (!outfile.is_open()) {
throw RuntimeError("Could not create file to save pattern");
}
// get pattern limits
auto r = pimpl->Parallel(&Module::getPatternLoopAddresses, {}, -1)
.tsquash("Inconsistent pattern limits");
CmdProxy proxy(this);
// pattern words
for (int i = r[0]; i <= r[1]; ++i) {
std::ostringstream os;
os << "0x" << std::hex << i;
auto addr = os.str();
proxy.Call("patword", {addr}, -1, defs::GET_ACTION, outfile);
}
// rest of pattern file
std::vector<std::string> commands{
"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) {
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) {
pimpl->Parallel(&Module::setPatternStructure, pos, pat);
pimpl->Parallel(&Module::setPattern, pos, pat);
}
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
void Module::setPattern(const std::string &fname) {
auto pat = sls::make_unique<patternParameters>();
pat->load(fname);
setPatternStructure(pat.get());
void Module::setPattern(const defs::patternParameters *pat) {
pat->validate();
sendToDetector(F_SET_PATTERN, pat, sizeof(patternParameters), nullptr, 0);
}
void Module::setPatternStructure(const defs::patternParameters *pat) {
// verifications
if (pat->patlimits[0] >= MAX_PATTERN_LENGTH ||
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);
void Module::getPattern(defs::patternParameters *pat) {
*pat = sendToDetector<defs::patternParameters>(F_GET_PATTERN);
pat->validate();
}
uint64_t Module::getPatternIOControl() const {

4
slsDetectorSoftware/src/Module.h
View File

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

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]));
}
}
}