WIP

slsDetectorSoftware/include/sls/Pattern.h

@@ -18,25 +18,24 @@ typedef struct __attribute__((packed)) {
     uint64_t waittime[3];
 } patternParameters;
 
-
 #ifdef __cplusplus
-class Pattern{
-    patternParameters* pat = new patternParameters{};
-    
-    public:
-        Pattern();
-        ~Pattern();
-        Pattern(const Pattern& other);
-        bool operator==(const Pattern& other) const;
-        bool operator!=(const Pattern& other) const;
-        patternParameters* data();
-        patternParameters* data() const;
-        constexpr size_t size() const  noexcept{ return sizeof(patternParameters);}
-        void validate() const;
-        void load(const std::string &fname);
-        std::string str() const { return {}; }
+class Pattern {
+    patternParameters *pat = new patternParameters{};
 
+  public:
+    Pattern();
+    ~Pattern();
+    Pattern(const Pattern &other);
+    bool operator==(const Pattern &other) const;
+    bool operator!=(const Pattern &other) const;
+    patternParameters *data();
+    patternParameters *data() const;
+    constexpr size_t size() const noexcept { return sizeof(patternParameters); }
+    void validate() const;
+    void load(const std::string &fname);
+    void save(const std::string &fname);
+    std::string str() const { return {}; }
 };
 
-} //namespace sls
+} // namespace sls
 #endif

slsDetectorSoftware/src/Detector.cpp

@@ -1758,7 +1758,8 @@ void Detector::savePattern(const std::string &fname) {
     auto t = pimpl->Parallel(&Module::getPattern, {});
     auto pat = t.tsquash("Inconsistent pattern parameters between modules");
     pat.validate();
-    // pat.save(fname);
+    std::cout << ToString(pat) << std::endl;
+    pat.save(fname);
 }
 
 void Detector::setPattern(const std::string &fname, Positions pos) {

slsDetectorSoftware/src/Module.cpp

@@ -1913,7 +1913,7 @@ void Module::setLEDEnable(bool enable) {
 
 // Pattern
 
-void Module::setPattern(const Pattern& pat) {
+void Module::setPattern(const Pattern &pat) {
     sendToDetector(F_SET_PATTERN, pat.data(), pat.size(), nullptr, 0);
 }
 

slsDetectorSoftware/src/Pattern.cpp

@@ -15,38 +15,40 @@ Pattern::Pattern(const Pattern &other) {
 }
 
 bool Pattern::operator==(const Pattern &other) const {
-    for (size_t i = 0; i<(sizeof(pat->word)/sizeof(pat->word[0])); ++i){
+    for (size_t i = 0; i < (sizeof(pat->word) / sizeof(pat->word[0])); ++i) {
         if (pat->word[i] != other.pat->word[i])
             return false;
     }
     if (pat->ioctrl != other.pat->ioctrl)
         return false;
-    
-    for (size_t i = 0; i<(sizeof(pat->limits)/sizeof(pat->limits[0])); ++i){
+
+    for (size_t i = 0; i < (sizeof(pat->limits) / sizeof(pat->limits[0]));
+         ++i) {
         if (pat->limits[i] != other.pat->limits[i])
             return false;
     }
-    for (size_t i = 0; i<(sizeof(pat->loop)/sizeof(pat->loop[0])); ++i){
+    for (size_t i = 0; i < (sizeof(pat->loop) / sizeof(pat->loop[0])); ++i) {
         if (pat->loop[i] != other.pat->loop[i])
             return false;
     }
-    for (size_t i = 0; i<(sizeof(pat->nloop)/sizeof(pat->nloop[0])); ++i){
+    for (size_t i = 0; i < (sizeof(pat->nloop) / sizeof(pat->nloop[0])); ++i) {
         if (pat->nloop[i] != other.pat->nloop[i])
             return false;
     }
-    for (size_t i = 0; i<(sizeof(pat->wait)/sizeof(pat->wait[0])); ++i){
+    for (size_t i = 0; i < (sizeof(pat->wait) / sizeof(pat->wait[0])); ++i) {
         if (pat->wait[i] != other.pat->wait[i])
             return false;
     }
-    for (size_t i = 0; i<(sizeof(pat->waittime)/sizeof(pat->waittime[0])); ++i){
+    for (size_t i = 0; i < (sizeof(pat->waittime) / sizeof(pat->waittime[0]));
+         ++i) {
         if (pat->waittime[i] != other.pat->waittime[i])
             return false;
     }
     return true;
 }
 
-bool Pattern::operator!=(const Pattern& other) const{
-    return !(*this==other);
+bool Pattern::operator!=(const Pattern &other) const {
+    return !(*this == other);
 }
 
 patternParameters *Pattern::data() { return pat; }
@@ -163,4 +165,43 @@ void Pattern::load(const std::string &fname) {
     }
 }
 
+void Pattern::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 = pat->limits[0]; i <= pat->limits[1]; ++i) {
+        output_file << "patword [" << ToStringHex(i, 4) << ", "
+                    << ToStringHex(pat->word[i], 16) << "]" << std::endl;
+    }
+
+    // patioctrl
+    output_file << "patioctrl " << ToStringHex(pat->ioctrl, 16) << std::endl;
+
+    // patlimits
+    output_file << "patlimits " << ToStringHex(pat->limits[0], 4) << " "
+                << ToStringHex(pat->limits[1], 4) << std::endl;
+
+    for (size_t i = 0; i < 3; ++i) {
+        // patloop
+        output_file << "patloop" << i << " "
+                    << ToStringHex(pat->loop[i * 2 + 0], 4) << " "
+                    << ToStringHex(pat->loop[i * 2 + 1], 4) << std::endl;
+        // patnloop
+        output_file << "patnloop" << i << " " << pat->nloop[i] << std::endl;
+    }
+
+    for (size_t i = 0; i < 3; ++i) {
+        // patwait
+        output_file << "patwait" << i << " " << ToStringHex(pat->wait[i], 4)
+                    << std::endl;
+        // patwaittime
+        output_file << "patwaittime" << i << " " << pat->waittime[i]
+                    << std::endl;
+    }
+}
+
 } // namespace sls