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

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;