diff --git a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h index 2373cd901..9994d255e 100644 --- a/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h +++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h @@ -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); \ No newline at end of file +int is_virtual(int); +int get_pattern(int); \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c index 831a29414..ede5d5c86 100644 --- a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c +++ b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c @@ -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)); diff --git a/slsDetectorSoftware/src/Detector.cpp b/slsDetectorSoftware/src/Detector.cpp index b5012beba..b90c10df9 100644 --- a/slsDetectorSoftware/src/Detector.cpp +++ b/slsDetectorSoftware/src/Detector.cpp @@ -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> patlist; + for (int i = 0; i < patlist.size(); ++i) { + patlist[i] = sls::make_unique(); } - // get pattern limits - auto r = pimpl->Parallel(&Module::getPatternLoopAddresses, {}, -1) - .tsquash("Inconsistent pattern limits"); + Result pat; + = sls::make_unique(); + 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 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 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(); + 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 Detector::getPatternIOControl(Positions pos) const { diff --git a/slsDetectorSoftware/src/Module.cpp b/slsDetectorSoftware/src/Module.cpp index 6fb9c04fc..aa561ab56 100644 --- a/slsDetectorSoftware/src/Module.cpp +++ b/slsDetectorSoftware/src/Module.cpp @@ -1913,37 +1913,14 @@ void Module::setLEDEnable(bool enable) { // Pattern -void Module::setPattern(const std::string &fname) { - auto pat = sls::make_unique(); - 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(F_GET_PATTERN); + pat->validate(); } uint64_t Module::getPatternIOControl() const { diff --git a/slsDetectorSoftware/src/Module.h b/slsDetectorSoftware/src/Module.h index 451c544e4..c961d7d19 100644 --- a/slsDetectorSoftware/src/Module.h +++ b/slsDetectorSoftware/src/Module.h @@ -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; diff --git a/slsSupportLib/include/sls/sls_detector_defs.h b/slsSupportLib/include/sls/sls_detector_defs.h index 1681bdbf0..4f12a5a85 100644 --- a/slsSupportLib/include/sls/sls_detector_defs.h +++ b/slsSupportLib/include/sls/sls_detector_defs.h @@ -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 diff --git a/slsSupportLib/include/sls/sls_detector_funcs.h b/slsSupportLib/include/sls/sls_detector_funcs.h index 8ea0bcee7..693705d99 100755 --- a/slsSupportLib/include/sls/sls_detector_funcs.h +++ b/slsSupportLib/include/sls/sls_detector_funcs.h @@ -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"; diff --git a/slsSupportLib/src/ToString.cpp b/slsSupportLib/src/ToString.cpp index 9b9944e28..80b5a1983 100644 --- a/slsSupportLib/src/ToString.cpp +++ b/slsSupportLib/src/ToString.cpp @@ -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(); } diff --git a/slsSupportLib/src/sls_detector_defs.cpp b/slsSupportLib/src/sls_detector_defs.cpp index fc00ecaab..37b64f98a 100644 --- a/slsSupportLib/src/sls_detector_defs.cpp +++ b/slsSupportLib/src/sls_detector_defs.cpp @@ -1,16 +1,16 @@ #include "sls/sls_detector_defs.h" -#include "sls/logger.h" #include "sls/ToString.h" +#include "sls/logger.h" #include -#include #include +#include 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(args[1]); + ioctrl = StringTo(args[1]); } else if (cmd == "patlimits") { if (nargs != 2) { throw RuntimeError("Invalid arguments for " + ToString(args)); } - patlimits[0] = StringTo(args[1]); - patlimits[1] = StringTo(args[2]); + limits[0] = StringTo(args[1]); + limits[1] = StringTo(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(args[1]); - int patloop2 = StringTo(args[2]); - patloop[level * 2 + 0] = patloop1; - patloop[level * 2 + 1] = patloop2; + int loop1 = StringTo(args[1]); + int loop2 = StringTo(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(args[1]); + nloop[level] = StringTo(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(args[1]); + wait[level] = StringTo(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(args[1]); + waittime[level] = StringTo(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(iss); + std::vector args = std::vector( + it, std::istream_iterator()); + + 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(args[1]); + if (addr >= MAX_PATTERN_LENGTH) { + throw RuntimeError("Invalid address for " + + ToString(args)); + } + word[addr] = StringTo(args[2]); + } else if (cmd == "patioctrl") { + if (nargs != 1) { + throw RuntimeError("Invalid arguments for " + + ToString(args)); + } + patioctrl = StringTo(args[1]); + } else if (cmd == "patlimits") { + if (nargs != 2) { + throw RuntimeError("Invalid arguments for " + + ToString(args)); + } + patlimits[0] = StringTo(args[1]); + patlimits[1] = StringTo(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(args[1]); + int patloop2 = StringTo(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(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(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(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])); + } + } } \ No newline at end of file