Pattern 6 levels (#493)

* separating pattern levels from command name: command line done * separated patten level from command in examples and default pattern files in servers * command line and server works * python: patnloop not verified, wip * works except for patloop (set, and get does not list properly) * minor * fixed tests * added 3 more levels for ctb and moench * wip * minor err msg * minor * binaries in * separating pattern levels from command name: command line done * separated patten level from command in examples and default pattern files in servers * command line and server works * python: patnloop not verified, wip * works except for patloop (set, and get does not list properly) * minor * fixed tests * added 3 more levels for ctb and moench * wip * minor err msg * minor * binaries in * python working * import fix * changed fw version for ctb and moench. binaries in Co-authored-by: Erik Frojdh <erik.frojdh@gmail.com>
2026-01-16 11:13:44 +01:00 · 2022-07-14 12:00:07 +02:00
parent 5be50785fb
commit 8fcec81a67
31 changed files with 955 additions and 643 deletions
--- a/slsDetectorSoftware/include/sls/Pattern.h
+++ b/slsDetectorSoftware/include/sls/Pattern.h
@@ -13,11 +13,11 @@ typedef struct __attribute__((packed)) {
    uint64_t word[MAX_PATTERN_LENGTH];
    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];
+    uint32_t startloop[MAX_PATTERN_LEVELS];
+    uint32_t stoploop[MAX_PATTERN_LEVELS];
+    uint32_t nloop[MAX_PATTERN_LEVELS];
+    uint32_t wait[MAX_PATTERN_LEVELS];
+    uint64_t waittime[MAX_PATTERN_LEVELS];
 } patternParameters;

 #ifdef __cplusplus
--- a/slsDetectorSoftware/src/CmdProxy.cpp
+++ b/slsDetectorSoftware/src/CmdProxy.cpp
@@ -2705,7 +2705,30 @@ std::string CmdProxy::PatternWord(int action) {
    return os.str();
 }

+void CmdProxy::GetLevelAndUpdateArgIndex(int action, std::string levelSeparatedCommand, int& level, int& iArg, size_t nGetArgs, size_t nPutArgs) {
+    if (cmd == levelSeparatedCommand) {
+        ++nGetArgs;
+        ++nPutArgs;
+    } else {
+        LOG(logWARNING) << "This command is deprecated and will be removed. Please migrate to " << levelSeparatedCommand;
+    }
+    if (action == defs::GET_ACTION && args.size() != nGetArgs) {
+        WrongNumberOfParameters(nGetArgs);
+    } else if (action == defs::PUT_ACTION && args.size() != nPutArgs) {
+        WrongNumberOfParameters(nPutArgs);
+    } 
+    if (cmd == levelSeparatedCommand) {
+        level = StringTo<int>(args[iArg++]);   
+    } else {
+        level = cmd[cmd.find_first_of("012")] - '0';
+    }
+}
+
 std::string CmdProxy::PatternLoopAddresses(int action) {
+   if (cmd != "patlimits" && cmd != "patloop0" && cmd != "patloop1" && cmd != "patloop2" && cmd != "patloop") { 
+        throw RuntimeError(
+                "Unknown command, use list to list all commands");
+   }
    std::ostringstream os;
    os << cmd << ' ';
    if (action == defs::HELP_ACTION) {
@@ -2713,53 +2736,30 @@ std::string CmdProxy::PatternLoopAddresses(int action) {
            os << "[start addr] [stop addr] \n\t[Ctb][Moench][Mythen3] Limits "
                  "of complete pattern."
               << '\n';
-        } else if (cmd == "patloop0") {
-            os << "[start addr] [stop addr] \n\t[Ctb][Moench][Mythen3] Limits "
-                  "of loop 0."
-               << '\n';
-        } else if (cmd == "patloop1") {
-            os << "[start addr] [stop addr] \n\t[Ctb][Moench][Mythen3] Limits "
-                  "of loop 1."
-               << '\n';
-        } else if (cmd == "patloop2") {
-            os << "[start addr] [stop addr] \n\t[Ctb][Moench][Mythen3] Limits "
-                  "of loop 2."
+        } else if (cmd == "patloop") {
+            os << "[0-6] [start addr] [stop addr] \n\t[Ctb][Moench][Mythen3] Limits of the loop level provided."
+                << "\n\t[Mythen3] Level options: 0-3 only."
               << '\n';
        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
-        }
+            os << "Depreciated command. Use patloop."
+               << '\n';
+        } 
    } else {
-        int level = -1;
-        if (cmd == "patlimits") {
-            level = -1;
-        } else if (cmd == "patloop0") {
-            level = 0;
-        } else if (cmd == "patloop1") {
-            level = 1;
-        } else if (cmd == "patloop2") {
-            level = 2;
-        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
+        int level = -1, iArg = 0, nGetArgs = 0, nPutArgs = 2;
+        if (cmd != "patlimits") {
+            GetLevelAndUpdateArgIndex(action, "patloop", level, iArg, nGetArgs, nPutArgs);
        }
        if (action == defs::GET_ACTION) {
-            if (!args.empty()) {
-                WrongNumberOfParameters(0);
-            }
            auto t =
                det->getPatternLoopAddresses(level, std::vector<int>{det_id});
            os << OutStringHex(t, 4) << '\n';
        } else if (action == defs::PUT_ACTION) {
-            if (args.size() != 2) {
-                WrongNumberOfParameters(2);
-            }
-            int start = StringTo<int>(args[0]);
-            int stop = StringTo<int>(args[1]);
+            int start = StringTo<int>(args[iArg++]);
+            int stop = StringTo<int>(args[iArg++]);            
            det->setPatternLoopAddresses(level, start, stop,
-                                         std::vector<int>{det_id});
+                                            std::vector<int>{det_id});
            os << '[' << ToStringHex(start, 4) << ", " << ToStringHex(stop, 4)
-               << "]\n";
+                << "]\n";
        } else {
            throw RuntimeError("Unknown action");
        }
@@ -2768,50 +2768,32 @@ std::string CmdProxy::PatternLoopAddresses(int action) {
 }

 std::string CmdProxy::PatternLoopCycles(int action) {
+   if (cmd != "patnloop0" && cmd != "patnloop1" && cmd != "patnloop2" && cmd != "patnloop") { 
+        throw RuntimeError(
+                "Unknown command, use list to list all commands");
+   }
    std::ostringstream os;
    os << cmd << ' ';
    if (action == defs::HELP_ACTION) {
-        if (cmd == "patnloop0") {
-            os << "[n_cycles] \n\t[Ctb][Moench][Mythen3] Number of cycles of "
-                  "loop 0."
-               << '\n';
-        } else if (cmd == "patnloop1") {
-            os << "[n_cycles] \n\t[Ctb][Moench][Mythen3] Number of cycles of "
-                  "loop 1."
-               << '\n';
-        } else if (cmd == "patnloop2") {
-            os << "[n_cycles] \n\t[Ctb][Moench][Mythen3] Number of cycles of "
-                  "loop 2."
+        if (cmd == "patnloop") {
+            os << "[0-6] [n_cycles] \n\t[Ctb][Moench][Mythen3] Number of cycles of "
+                  "the loop level provided."
+                << "\n\t[Mythen3] Level options: 0-3 only."
               << '\n';
        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
-        }
+            os << "Depreciated command. Use patnloop."
+               << '\n';
+        } 
    } else {
-        int level = -1;
-        if (cmd == "patnloop0") {
-            level = 0;
-        } else if (cmd == "patnloop1") {
-            level = 1;
-        } else if (cmd == "patnloop2") {
-            level = 2;
-        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
-        }
+        int level = -1, iArg = 0, nGetArgs = 0, nPutArgs = 1;
+        GetLevelAndUpdateArgIndex(action, "patnloop", level, iArg, nGetArgs, nPutArgs);
        if (action == defs::GET_ACTION) {
-            if (!args.empty()) {
-                WrongNumberOfParameters(0);
-            }
            auto t = det->getPatternLoopCycles(level, std::vector<int>{det_id});
            os << OutString(t) << '\n';
        } else if (action == defs::PUT_ACTION) {
-            if (args.size() != 1) {
-                WrongNumberOfParameters(1);
-            }
-            det->setPatternLoopCycles(level, StringTo<int>(args[0]),
-                                      std::vector<int>{det_id});
-            os << args.front() << '\n';
+            int nloops = StringTo<int>(args[iArg++]);
+            det->setPatternLoopCycles(level, nloops, std::vector<int>{det_id});
+            os << nloops << '\n';
        } else {
            throw RuntimeError("Unknown action");
        }
@@ -2820,42 +2802,28 @@ std::string CmdProxy::PatternLoopCycles(int action) {
 }

 std::string CmdProxy::PatternWaitAddress(int action) {
+   if (cmd != "patwait0" && cmd != "patwait1" && cmd != "patwait2" && cmd != "patwait") { 
+        throw RuntimeError(
+                "Unknown command, use list to list all commands");
+   }
    std::ostringstream os;
    os << cmd << ' ';
    if (action == defs::HELP_ACTION) {
-        if (cmd == "patwait0") {
-            os << "[addr] \n\t[Ctb][Moench][Mythen3] Wait 0 address." << '\n';
-        } else if (cmd == "patwait1") {
-            os << "[addr] \n\t[Ctb][Moench][Mythen3] Wait 1 address." << '\n';
-        } else if (cmd == "patwait2") {
-            os << "[addr] \n\t[Ctb][Moench][Mythen3] Wait 2 address." << '\n';
+        if (cmd == "patwait") {
+            os << "[0-6] [addr] \n\t[Ctb][Moench][Mythen3] Wait address for loop level provided." 
+                << "\n\t[Mythen3] Level options: 0-3 only.";
        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
+            os << "Depreciated command. Use patwait.";
        }
+        os << '\n';
    } else {
-        int level = -1;
-        if (cmd == "patwait0") {
-            level = 0;
-        } else if (cmd == "patwait1") {
-            level = 1;
-        } else if (cmd == "patwait2") {
-            level = 2;
-        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
-        }
+        int level = -1, iArg = 0, nGetArgs = 0, nPutArgs = 1;
+        GetLevelAndUpdateArgIndex(action, "patwait", level, iArg, nGetArgs, nPutArgs);
        if (action == defs::GET_ACTION) {
-            if (!args.empty()) {
-                WrongNumberOfParameters(0);
-            }
            auto t = det->getPatternWaitAddr(level, std::vector<int>{det_id});
            os << OutStringHex(t, 4) << '\n';
        } else if (action == defs::PUT_ACTION) {
-            if (args.size() != 1) {
-                WrongNumberOfParameters(1);
-            }
-            int addr = StringTo<int>(args[0]);
+            int addr = StringTo<int>(args[iArg++]);
            det->setPatternWaitAddr(level, addr, std::vector<int>{det_id});
            os << ToStringHex(addr, 4) << '\n';
        } else {
@@ -2866,50 +2834,32 @@ std::string CmdProxy::PatternWaitAddress(int action) {
 }

 std::string CmdProxy::PatternWaitTime(int action) {
+    if (cmd != "patwaittime0" && cmd != "patwaittime1" && cmd != "patwaittime2" && cmd != "patwaittime") { 
+        throw RuntimeError(
+                "Unknown command, use list to list all commands");
+    }
    std::ostringstream os;
    os << cmd << ' ';
    if (action == defs::HELP_ACTION) {
-        if (cmd == "patwaittime0") {
-            os << "[n_clk] \n\t[Ctb][Moench][Mythen3] Wait 0 time in clock "
-                  "cycles."
-               << '\n';
-        } else if (cmd == "patwaittime1") {
-            os << "[n_clk] \n\t[Ctb][Moench][Mythen3] Wait 1 time in clock "
-                  "cycles."
-               << '\n';
-        } else if (cmd == "patwaittime2") {
-            os << "[n_clk] \n\t[Ctb][Moench][Mythen3] Wait 2 time in clock "
-                  "cycles."
+        if (cmd == "patwaittime") {
+            os << "[0-6] [n_clk] \n\t[Ctb][Moench][Mythen3] Wait time in clock "
+                  "cycles for the loop provided."
+                << "\n\t[Mythen3] Level options: 0-3 only."
               << '\n';
        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
-        }
+            os << "Depreciated command. Use patwaittime."
+               << '\n';
+        } 
    } else {
-        int level = -1;
-        if (cmd == "patwaittime0") {
-            level = 0;
-        } else if (cmd == "patwaittime1") {
-            level = 1;
-        } else if (cmd == "patwaittime2") {
-            level = 2;
-        } else {
-            throw RuntimeError(
-                "Unknown command, use list to list all commands");
-        }
+        int level = -1, iArg = 0, nGetArgs = 0, nPutArgs = 1;
+        GetLevelAndUpdateArgIndex(action, "patwaittime", level, iArg, nGetArgs, nPutArgs);
        if (action == defs::GET_ACTION) {
-            if (!args.empty()) {
-                WrongNumberOfParameters(0);
-            }
            auto t = det->getPatternWaitTime(level, std::vector<int>{det_id});
            os << OutString(t) << '\n';
        } else if (action == defs::PUT_ACTION) {
-            if (args.size() != 1) {
-                WrongNumberOfParameters(1);
-            }
-            det->setPatternWaitTime(level, StringTo<uint64_t>(args[0]),
-                                    {det_id});
-            os << args.front() << '\n';
+            uint64_t waittime = StringTo<uint64_t>(args[iArg++]);
+            det->setPatternWaitTime(level, waittime, {det_id});
+            os << waittime << '\n';
        } else {
            throw RuntimeError("Unknown action");
        }
--- a/slsDetectorSoftware/src/CmdProxy.h
+++ b/slsDetectorSoftware/src/CmdProxy.h
@@ -1049,15 +1049,19 @@ class CmdProxy {
        {"patioctrl", &CmdProxy::patioctrl},
        {"patword", &CmdProxy::PatternWord},
        {"patlimits", &CmdProxy::PatternLoopAddresses},
+        {"patloop", &CmdProxy::PatternLoopAddresses},
        {"patloop0", &CmdProxy::PatternLoopAddresses},
        {"patloop1", &CmdProxy::PatternLoopAddresses},
        {"patloop2", &CmdProxy::PatternLoopAddresses},
+        {"patnloop", &CmdProxy::PatternLoopCycles},
        {"patnloop0", &CmdProxy::PatternLoopCycles},
        {"patnloop1", &CmdProxy::PatternLoopCycles},
        {"patnloop2", &CmdProxy::PatternLoopCycles},
+        {"patwait", &CmdProxy::PatternWaitAddress},
        {"patwait0", &CmdProxy::PatternWaitAddress},
        {"patwait1", &CmdProxy::PatternWaitAddress},
        {"patwait2", &CmdProxy::PatternWaitAddress},
+        {"patwaittime", &CmdProxy::PatternWaitTime},
        {"patwaittime0", &CmdProxy::PatternWaitTime},
        {"patwaittime1", &CmdProxy::PatternWaitTime},
        {"patwaittime2", &CmdProxy::PatternWaitTime},
@@ -1192,6 +1196,7 @@ class CmdProxy {
    /* Pattern */
    std::string Pattern(int action);
    std::string PatternWord(int action);
+    void GetLevelAndUpdateArgIndex(int action, std::string levelSeparatedCommand, int& level, int& iArg, size_t nGetArgs, size_t nPutArgs);
    std::string PatternLoopAddresses(int action);
    std::string PatternLoopCycles(int action);
    std::string PatternWaitAddress(int action);
--- a/slsDetectorSoftware/src/Pattern.cpp
+++ b/slsDetectorSoftware/src/Pattern.cpp
@@ -29,8 +29,12 @@ bool Pattern::operator==(const Pattern &other) const {
        if (pat->limits[i] != other.pat->limits[i])
            return false;
    }
-    for (size_t i = 0; i < (sizeof(pat->loop) / sizeof(pat->loop[0])); ++i) {
-        if (pat->loop[i] != other.pat->loop[i])
+    for (size_t i = 0; i < (sizeof(pat->startloop) / sizeof(pat->startloop[0])); ++i) {
+        if (pat->startloop[i] != other.pat->startloop[i])
+            return false;
+    }
+    for (size_t i = 0; i < (sizeof(pat->stoploop) / sizeof(pat->stoploop[0])); ++i) {
+        if (pat->stoploop[i] != other.pat->stoploop[i])
            return false;
    }
    for (size_t i = 0; i < (sizeof(pat->nloop) / sizeof(pat->nloop[0])); ++i) {
@@ -63,13 +67,13 @@ void Pattern::validate() const {
                           ToString(pat->limits[0]) + std::string(", ") +
                           ToString(pat->limits[1]) + std::string("]"));
    }
-    for (int i = 0; i != 3; ++i) {
-        if (pat->loop[i * 2 + 0] >= MAX_PATTERN_LENGTH ||
-            pat->loop[i * 2 + 1] >= MAX_PATTERN_LENGTH) {
+    for (int i = 0; i != MAX_PATTERN_LEVELS; ++i) {
+        if (pat->startloop[i] >= MAX_PATTERN_LENGTH ||
+            pat->stoploop[i] >= MAX_PATTERN_LENGTH) {
            throw RuntimeError(
                "Invalid Pattern loop address for level " + ToString(i) +
-                std::string(" [") + ToString(pat->loop[i * 2 + 0]) +
-                std::string(", ") + ToString(pat->loop[i * 2 + 1]) +
+                std::string(" [") + ToString(pat->startloop[i]) +
+                std::string(", ") + ToString(pat->stoploop[i]) +
                std::string("]"));
        }
        if (pat->wait[i] >= MAX_PATTERN_LENGTH) {
@@ -125,41 +129,94 @@ void Pattern::load(const std::string &fname) {
                }
                pat->limits[0] = StringTo<uint32_t>(args[1]);
                pat->limits[1] = StringTo<uint32_t>(args[2]);
-            } else if (cmd == "patloop0" || cmd == "patloop1" ||
-                       cmd == "patloop2") {
-                if (nargs != 2) {
-                    throw RuntimeError("Invalid arguments for " +
-                                       ToString(args));
+            } 
+            else if (cmd == "patloop0" || cmd == "patloop1" ||
+                       cmd == "patloop2" || cmd == "patloop") {
+                int level = -1, iArg = 1;
+                if (cmd == "patloop") {
+                    if (nargs != 3) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = StringTo<int>(args[iArg++]);
+                } else {
+                    LOG(logWARNING) << "Depreciated command. Please use patloop next time.";
+                    if (nargs != 2) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = cmd[cmd.find_first_of("012")] - '0';
                }
-                int level = cmd[cmd.find_first_of("012")] - '0';
-                int loop1 = StringTo<uint32_t>(args[1]);
-                int loop2 = StringTo<uint32_t>(args[2]);
-                pat->loop[level * 2 + 0] = loop1;
-                pat->loop[level * 2 + 1] = loop2;
+                if (level < 0 || level >= MAX_PATTERN_LEVELS) {
+                    throw RuntimeError("Invalid Pattern level. Options 0-" + std::to_string(MAX_PATTERN_LEVELS - 1));
+                }
+                int loop1 = StringTo<uint32_t>(args[iArg++]);
+                int loop2 = StringTo<uint32_t>(args[iArg++]);
+                pat->startloop[level] = loop1;
+                pat->stoploop[level] = loop2;
            } else if (cmd == "patnloop0" || cmd == "patnloop1" ||
-                       cmd == "patnloop2") {
-                if (nargs != 1) {
-                    throw RuntimeError("Invalid arguments for " +
-                                       ToString(args));
+                       cmd == "patnloop2" || cmd == "patnloop") {
+                int level = -1, iArg = 1;
+                if (cmd == "patnloop") {
+                    if (nargs != 2) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = StringTo<int>(args[iArg++]);
+                } else {
+                    LOG(logWARNING) << "Depreciated command. Please use patnloop next time.";
+                    if (nargs != 1) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = cmd[cmd.find_first_of("012")] - '0';
                }
-                int level = cmd[cmd.find_first_of("012")] - '0';
-                pat->nloop[level] = StringTo<uint32_t>(args[1]);
+                if (level < 0 || level >= MAX_PATTERN_LEVELS) {
+                    throw RuntimeError("Invalid Pattern level. Options 0-" + std::to_string(MAX_PATTERN_LEVELS - 1));
+                }
+                pat->nloop[level] = StringTo<uint32_t>(args[iArg++]);
            } else if (cmd == "patwait0" || cmd == "patwait1" ||
-                       cmd == "patwait2") {
-                if (nargs != 1) {
-                    throw RuntimeError("Invalid arguments for " +
-                                       ToString(args));
+                       cmd == "patwait2" || cmd == "patwait") {
+                int level = -1, iArg = 1;
+                if (cmd == "patwait") {
+                    if (nargs != 2) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = StringTo<int>(args[iArg++]);
+                } else {
+                    LOG(logWARNING) << "Depreciated command. Please use patwait next time.";
+                    if (nargs != 1) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = cmd[cmd.find_first_of("012")] - '0';
                }
-                int level = cmd[cmd.find_first_of("012")] - '0';
-                pat->wait[level] = StringTo<uint32_t>(args[1]);
+                if (level < 0 || level >= MAX_PATTERN_LEVELS) {
+                    throw RuntimeError("Invalid Pattern level. Options 0-" + std::to_string(MAX_PATTERN_LEVELS - 1));
+                }
+                pat->wait[level] = StringTo<uint32_t>(args[iArg++]);
            } else if (cmd == "patwaittime0" || cmd == "patwaittime1" ||
-                       cmd == "patwaittime2") {
-                if (nargs != 1) {
-                    throw RuntimeError("Invalid arguments for " +
-                                       ToString(args));
+                       cmd == "patwaittime2" || cmd == "patwaittime") {
+                int level = -1, iArg = 1;
+                if (cmd == "patwaittime") {
+                    if (nargs != 2) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = StringTo<int>(args[iArg++]);
+                } else {
+                    LOG(logWARNING) << "Depreciated command. Please use patwaittime next time.";
+                    if (nargs != 1) {
+                        throw RuntimeError("Invalid arguments for " +
+                                        ToString(args));
+                    }
+                    level = cmd[cmd.find_first_of("012")] - '0';
                }
-                int level = cmd[cmd.find_first_of("012")] - '0';
-                pat->waittime[level] = StringTo<uint64_t>(args[1]);
+                if (level < 0 || level >= MAX_PATTERN_LEVELS) {
+                    throw RuntimeError("Invalid Pattern level. Options 0-" + std::to_string(MAX_PATTERN_LEVELS - 1));
+                }
+                pat->waittime[level] = StringTo<uint64_t>(args[iArg++]);
            } else {
                throw RuntimeError("Unknown command in pattern file " + cmd);
            }
@@ -187,21 +244,21 @@ void Pattern::save(const std::string &fname) {
    output_file << "patlimits " << ToStringHex(pat->limits[0], 4) << " "
                << ToStringHex(pat->limits[1], 4) << std::endl;

-    for (size_t i = 0; i < 3; ++i) {
+    for (size_t i = 0; i < MAX_PATTERN_LEVELS; ++i) {
        // patloop
-        output_file << "patloop" << i << " "
-                    << ToStringHex(pat->loop[i * 2 + 0], 4) << " "
-                    << ToStringHex(pat->loop[i * 2 + 1], 4) << std::endl;
+        output_file << "patloop " << i << " "
+                    << ToStringHex(pat->startloop[i], 4) << " "
+                    << ToStringHex(pat->stoploop[i], 4) << std::endl;
        // patnloop
-        output_file << "patnloop" << i << " " << pat->nloop[i] << std::endl;
+        output_file << "patnloop " << i << " " << pat->nloop[i] << std::endl;
    }

-    for (size_t i = 0; i < 3; ++i) {
+    for (size_t i = 0; i < MAX_PATTERN_LEVELS; ++i) {
        // patwait
-        output_file << "patwait" << i << " " << ToStringHex(pat->wait[i], 4)
+        output_file << "patwait " << i << " " << ToStringHex(pat->wait[i], 4)
                    << std::endl;
        // patwaittime
-        output_file << "patwaittime" << i << " " << pat->waittime[i]
+        output_file << "patwaittime " << i << " " << pat->waittime[i]
                    << std::endl;
    }
 }
@@ -219,23 +276,17 @@ std::string Pattern::str() const {
    }
    oss << "patioctrl " << ToStringHex(pat->ioctrl, word_width) << std::endl
        << "patlimits " << ToStringHex(pat->limits[0], addr_width) << " "
-        << ToStringHex(pat->limits[1], addr_width) << std::endl
-        << "patloop0 " << ToStringHex(pat->loop[0], addr_width) << " "
-        << ToStringHex(pat->loop[1], addr_width) << std::endl
-        << "patnloop0 " << pat->nloop[0] << std::endl
-        << "patloop1 " << ToStringHex(pat->loop[2], addr_width) << " "
-        << ToStringHex(pat->loop[3], addr_width) << std::endl
-        << "patnloop1 " << pat->nloop[1] << std::endl
-        << "patloop2 " << ToStringHex(pat->loop[4], addr_width) << " "
-        << ToStringHex(pat->loop[5], addr_width) << std::endl
-        << "patnloop2 " << pat->nloop[2] << std::endl
-        << "patwait0 " << ToStringHex(pat->wait[0], addr_width) << std::endl
-        << "patwaittime0 " << pat->waittime[0] << std::endl
-        << "patwait1 " << ToStringHex(pat->wait[1], addr_width) << std::endl
-        << "patwaittime1 " << pat->waittime[1] << std::endl
-        << "patwait2 " << ToStringHex(pat->wait[2], addr_width) << std::endl
-        << "patwaittime2 " << pat->waittime[2] << std::endl
-        << ']';
+        << ToStringHex(pat->limits[1], addr_width) << std::endl;
+
+    for (int i = 0; i != MAX_PATTERN_LEVELS; ++i) {
+        oss << "patloop " << i << ' ' << ToStringHex(pat->startloop[i], addr_width) << " "
+            << ToStringHex(pat->stoploop[i], addr_width) << std::endl
+            << "patnloop " << pat->nloop[i] << std::endl
+            << "patwait " << i << ' ' << ToStringHex(pat->wait[i], addr_width) << std::endl
+            << "patwaittime " << i << ' ' << pat->waittime[i] << std::endl;
+    }
+
+    oss << ']';
    return oss.str();
 }

--- a/slsDetectorSoftware/tests/test-CmdProxy-pattern.cpp
+++ b/slsDetectorSoftware/tests/test-CmdProxy-pattern.cpp
@@ -154,315 +154,187 @@ TEST_CASE("patlimits", "[.cmd]") {
    }
 }

-TEST_CASE("patloop0", "[.cmd]") {
+TEST_CASE("patloop", "[.cmd]") {
    Detector det;
    CmdProxy proxy(&det);
    auto det_type = det.getDetectorType().squash();

    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternLoopAddresses(0);
-        {
-            std::ostringstream oss;
-            proxy.Call("patloop0", {"0x20", "0x5c"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patloop0 [0x0020, 0x005c]\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patloop0", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patloop0 [0x0020, 0x005c]\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternLoopAddresses(0, prev_val[i][0], prev_val[i][1], {i});
+        for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
+            // m3 only has 3 levels
+            if (det_type == defs::MYTHEN3 && iLoop >= 3) {
+                continue;
+            }
+            auto prev_val = det.getPatternLoopAddresses(iLoop);
+            std::string sLoop = ToString(iLoop);
+            if (iLoop < 3) {
+                std::string deprecatedCmd = "patloop" + sLoop;
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {"0x20", "0x5c"}, -1, PUT, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " [0x0020, 0x005c]\n");
+                }
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {}, -1, GET, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " [0x0020, 0x005c]\n");
+                }
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patloop", {sLoop, "0x20", "0x5c"}, -1, PUT, oss);
+                REQUIRE(oss.str() == "patloop [0x0020, 0x005c]\n");
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patloop", {sLoop}, -1, GET, oss);
+                REQUIRE(oss.str() == "patloop [0x0020, 0x005c]\n");
+            }            
+            for (int iDet = 0; iDet != det.size(); ++iDet) {
+                det.setPatternLoopAddresses(iLoop, prev_val[iDet][0], prev_val[iDet][1], {iDet});
+            }
        }
    } else {
-        REQUIRE_THROWS(proxy.Call("patloop0", {}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("patloop", {"0"}, -1, GET));
    }
 }

-TEST_CASE("patloop1", "[.cmd]") {
+TEST_CASE("patnloop", "[.cmd]") {
    Detector det;
    CmdProxy proxy(&det);
    auto det_type = det.getDetectorType().squash();

    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternLoopAddresses(1);
-        {
-            std::ostringstream oss;
-            proxy.Call("patloop1", {"0x20", "0x5c"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patloop1 [0x0020, 0x005c]\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patloop1", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patloop1 [0x0020, 0x005c]\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternLoopAddresses(1, prev_val[i][0], prev_val[i][1], {i});
+        for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
+            // m3 only has 3 levels
+            if (det_type == defs::MYTHEN3 && iLoop >= 3) {
+                continue;
+            }
+            auto prev_val = det.getPatternLoopCycles(iLoop);
+            std::string sLoop = ToString(iLoop);
+            if (iLoop < 3) {
+                std::string deprecatedCmd = "patnloop" + sLoop;
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {"5"}, -1, PUT, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " 5\n");
+                }
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {}, -1, GET, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " 5\n");
+                }
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patnloop", {sLoop, "5"}, -1, PUT, oss);
+                REQUIRE(oss.str() == "patnloop 5\n");
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patnloop", {sLoop}, -1, GET, oss);
+                REQUIRE(oss.str() == "patnloop 5\n");
+            }
+            for (int iDet = 0; iDet != det.size(); ++iDet) {
+                det.setPatternLoopCycles(iLoop, prev_val[iDet], {iDet});
+            }
        }
    } else {
-        REQUIRE_THROWS(proxy.Call("patloop1", {}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("patnloop", {"0"}, -1, GET));
    }
 }

-TEST_CASE("patloop2", "[.cmd]") {
+TEST_CASE("patwait", "[.cmd]") {
    Detector det;
    CmdProxy proxy(&det);
    auto det_type = det.getDetectorType().squash();

    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternLoopAddresses(2);
-        {
-            std::ostringstream oss;
-            proxy.Call("patloop2", {"0x20", "0x5c"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patloop2 [0x0020, 0x005c]\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patloop2", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patloop2 [0x0020, 0x005c]\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternLoopAddresses(2, prev_val[i][0], prev_val[i][1], {i});
+        for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
+            // m3 only has 3 levels
+            if (det_type == defs::MYTHEN3 && iLoop >= 3) {
+                continue;
+            }
+            auto prev_val = det.getPatternWaitAddr(iLoop);
+            std::string sLoop = ToString(iLoop);
+            if (iLoop < 3) {
+                std::string deprecatedCmd = "patwait" + sLoop;
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {"0x5c"}, -1, PUT, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " 0x005c\n");
+                }
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {}, -1, GET, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " 0x005c\n");
+                }
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patwait", {sLoop, "0x5c"}, -1, PUT, oss);
+                REQUIRE(oss.str() == "patwait 0x005c\n");
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patwait", {sLoop}, -1, GET, oss);
+                REQUIRE(oss.str() == "patwait 0x005c\n");
+            }
+            for (int iDet = 0; iDet != det.size(); ++iDet) {
+                det.setPatternWaitAddr(iLoop, prev_val[iDet], {iDet});
+            }
        }
    } else {
-        REQUIRE_THROWS(proxy.Call("patloop2", {}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("patwait", {"0"}, -1, GET));
    }
 }

-TEST_CASE("patnloop0", "[.cmd]") {
+TEST_CASE("patwaittime", "[.cmd]") {
    Detector det;
    CmdProxy proxy(&det);
    auto det_type = det.getDetectorType().squash();

    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternLoopCycles(0);
-        {
-            std::ostringstream oss;
-            proxy.Call("patnloop0", {"5"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patnloop0 5\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patnloop0", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patnloop0 5\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternLoopCycles(0, prev_val[i], {i});
+        for (int iLoop = 0; iLoop != MAX_PATTERN_LEVELS; ++iLoop) {
+            // m3 only has 3 levels
+            if (det_type == defs::MYTHEN3 && iLoop >= 3) {
+                continue;
+            }
+            auto prev_val = det.getPatternWaitTime(iLoop);
+            std::string sLoop = ToString(iLoop);
+            if (iLoop < 3) {
+                std::string deprecatedCmd = "patwaittime" + sLoop;
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {"8589936640"}, -1, PUT, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " 8589936640\n");
+                }
+                {// depreciated
+                    std::ostringstream oss;
+                    proxy.Call(deprecatedCmd, {}, -1, GET, oss);
+                    REQUIRE(oss.str() == deprecatedCmd + " 8589936640\n");
+                }
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patwaittime", {sLoop, "8589936640"}, -1, PUT, oss);
+                REQUIRE(oss.str() == "patwaittime 8589936640\n");
+            }
+            {
+                std::ostringstream oss;
+                proxy.Call("patwaittime", {sLoop}, -1, GET, oss);
+                REQUIRE(oss.str() == "patwaittime 8589936640\n");
+            }
+            for (int iDet = 0; iDet != det.size(); ++iDet) {
+                det.setPatternWaitTime(iLoop, prev_val[iDet], {iDet});
+            }
        }
    } else {
-        REQUIRE_THROWS(proxy.Call("patnloop0", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patnloop1", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternLoopCycles(1);
-        {
-            std::ostringstream oss;
-            proxy.Call("patnloop1", {"5"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patnloop1 5\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patnloop1", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patnloop1 5\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternLoopCycles(1, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patnloop1", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patnloop2", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternLoopCycles(2);
-        {
-            std::ostringstream oss;
-            proxy.Call("patnloop2", {"5"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patnloop2 5\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patnloop2", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patnloop2 5\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternLoopCycles(2, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patnloop2", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patwait0", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternWaitAddr(0);
-        {
-            std::ostringstream oss;
-            proxy.Call("patwait0", {"0x5c"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patwait0 0x005c\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patwait0", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patwait0 0x005c\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternWaitAddr(0, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patwait0", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patwait1", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternWaitAddr(1);
-        {
-            std::ostringstream oss;
-            proxy.Call("patwait1", {"0x5c"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patwait1 0x005c\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patwait1", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patwait1 0x005c\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternWaitAddr(1, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patwait1", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patwait2", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternWaitAddr(2);
-        {
-            std::ostringstream oss;
-            proxy.Call("patwait2", {"0x5c"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patwait2 0x005c\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patwait2", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patwait2 0x005c\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternWaitAddr(2, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patwait2", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patwaittime0", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternWaitTime(0);
-        {
-            std::ostringstream oss;
-            proxy.Call("patwaittime0", {"8589936640"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patwaittime0 8589936640\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patwaittime0", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patwaittime0 8589936640\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternWaitTime(0, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patwaittime0", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patwaittime1", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternWaitTime(1);
-        {
-            std::ostringstream oss;
-            proxy.Call("patwaittime1", {"8589936640"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patwaittime1 8589936640\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patwaittime1", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patwaittime1 8589936640\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternWaitTime(1, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patwaittime1", {}, -1, GET));
-    }
-}
-
-TEST_CASE("patwaittime2", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
-        det_type == defs::MYTHEN3) {
-        auto prev_val = det.getPatternWaitTime(2);
-        {
-            std::ostringstream oss;
-            proxy.Call("patwaittime2", {"8589936640"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "patwaittime2 8589936640\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("patwaittime2", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "patwaittime2 8589936640\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPatternWaitTime(2, prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("patwaittime2", {}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("patwaittime", {"0"}, -1, GET));
    }
 }

--- a/slsDetectorSoftware/tests/test-Pattern.cpp
+++ b/slsDetectorSoftware/tests/test-Pattern.cpp
@@ -14,9 +14,9 @@ TEST_CASE("Pattern is default constructable and has zeroed fields") {

 TEST_CASE("Copy construct pattern") {
    Pattern p;
-    p.data()->loop[0] = 7;
+    p.data()->startloop[0] = 7;
    Pattern p1(p);
-    REQUIRE(p1.data()->loop[0] == 7);
+    REQUIRE(p1.data()->startloop[0] == 7);
 }

 TEST_CASE("Compare patterns") {