[swt] Introduce wait operation

Author: kostorr

README.md

@@ -79,7 +79,7 @@ The services are DIM RPC services. Every RPC is called with a string and expects
   * Sequence of SCA operations as follows:
     * Operations may be:
     * An SCA command and data pair (e.g. `0x0000f00d,0x0000cafe`)
-    * A wait operation (e.g. `30,wait`)
+    * A wait operation (e.g. `30,wait`) in ms, defaults to 3
     * An instruction to execute the sequence atomically (`lock` - needs to lead the sequence)
 * Returns:
   * Sequence of SCA command and SCA read pairs, and wait confirmations
@@ -97,12 +97,14 @@ The services are DIM RPC services. Every RPC is called with a string and expects
     * `write` with SWT prefix (e.g. `0x0000f00d,write`)
     * `reset` (without SWT word)
     * `read` with optional TimeOut prefix (e.g. `2,read`)
+    * `wait` with optional WaitTime prefix in ms (e.g. `5,wait`), defaults to 3
     * `lock` which instructs ALF to execute the sequence atomically (needs to lead the sequence)
 * Returns:
   * Sequence of SWT output as follows:
     * `write` always retuns `0`
     * `read` returns the SWT words present in the CRU SWT FIFO
     * `reset` returns nothing
+    * `wait` returns time waited
     * `lock` returns nothing
 
 * Example:
@@ -218,7 +220,7 @@ All the above offer **no implicit locking** and should be manually locked throug
 ### Sequences of operations
 All SC classes offer a function to execute a sequence of their respective operations. This function receives an `std::vector`, consisting of an `std::pair` made up of the compatible SC operation and SC data, as these are defined in their headers.
 
-For example, `SWT` offers `Read, Write and Reset` operations which expect a `TimeOut`, an `SwtWord` and no argument, respectively.
+For example, `SWT` offers `Read, Write, Wait, and Reset` operations which expect a `TimeOut`, an `SwtWord`, a `WaitTime`, and no argument, respectively.
 
 ```
 typedef int TimeOut;
@@ -230,6 +232,7 @@ typedef boost::variant<boost::blank, TimeOut, SwtWord, std::string> Data;
 /// Enum for the different SWT operation types
 enum Operation { Read,
                  Write,
+                 WaitTime,
                  Reset,
                  Error };
                  

apps/AlfClient.cxx

@@ -161,6 +161,7 @@ class AlfClient : public AliceO2::Common::Program
                                         std::make_pair("0x0000000000000000000", "write"),
                                         std::make_pair("0x000000001234", "write"),
                                         std::make_pair("", "read"),
+                                        std::make_pair("200", "wait"),
                                         std::make_pair("0xdeadbeef", "write"),
                                         std::make_pair("1", "read"),
                                         std::make_pair("0xbadc0ffee", "write"),

apps/AlfLibClient.cxx

@@ -88,7 +88,7 @@ class AlfLibClient : public AliceO2::Common::Program
         if (out.first == Sca::Operation::Command) {
           std::cout << "Command: " << boost::get<Sca::CommandData>(out.second) << std::endl;
         } else if (out.first == Sca::Operation::Wait) {
-          std::cout << "Wait: " << boost::get<Sca::WaitTime>(out.second) << std::endl;
+          std::cout << "Wait: " << std::dec << boost::get<Sca::WaitTime>(out.second) << std::endl;
         } else if (out.first == Sca::Operation::Error) {
           std::cout << "Error: " << boost::get<std::string>(out.second) << std::endl;
         } else {
@@ -126,6 +126,7 @@ class AlfLibClient : public AliceO2::Common::Program
       ops.push_back({ Swt::Operation::Write, SwtWord{ 0xb00f, 0x42, 0x88, SwtWord::Size::High } });
       ops.push_back({ Swt::Operation::Write, SwtWord{ 0xb00f, 0x42, 0x88 } });
       ops.push_back({ Swt::Operation::Read, {} });
+      ops.push_back({ Swt::Operation::Wait, 100 });
       ops.push_back({ Swt::Operation::Write, SwtWord{ 0x1, 0x0, 0x0, SwtWord::Size::Low } });
       ops.push_back({ Swt::Operation::Write, SwtWord{ 0xb00f, 0x42, 0x88, SwtWord::Size::Low } });
       ops.push_back({ Swt::Operation::Write, SwtWord{ 0xcafe, 0x41d, 0x0 } });
@@ -143,6 +144,8 @@ class AlfLibClient : public AliceO2::Common::Program
           std::cout << "Read  | " << boost::get<SwtWord>(out.second) << std::endl;
         } else if (out.first == Swt::Operation::Reset) {
           std::cout << "Reset |" /* boost::blank here */ << std::endl;
+        } else if (out.first == Swt::Operation::Wait) {
+          std::cout << "Wait  | " << std::dec << boost::get<int>(out.second) << std::endl;
         } else if (out.first == Swt::Operation::Error) {
           std::cout << "Error | " << boost::get<std::string>(out.second) << std::endl;
         } else {

include/Alf/Swt.h

@@ -48,16 +48,17 @@ namespace alf
 class Swt
 {
  public:
-  typedef int TimeOut;
+  typedef int TimeOut, WaitTime;
 
   /// Typedef for the Data type of an SWT sequence operation.
   /// Variant of TimeOut for reads, SwtWord for writes, std::string for Errors
-  typedef boost::variant<boost::blank, TimeOut, SwtWord, std::string> Data;
+  typedef boost::variant<boost::blank, TimeOut, WaitTime, SwtWord, std::string> Data;
 
   /// Enum for the different SWT operation types
   enum Operation { Read,
                    Write,
                    Reset,
+                   Wait,
                    Error,
                    Lock };
 
@@ -125,6 +126,7 @@ class Swt
   AlfLink mLink;
   std::unique_ptr<LlaSession> mLlaSession;
 
+  static constexpr int DEFAULT_SWT_WAIT_TIME_MS = 3;
   static constexpr int DEFAULT_SWT_TIMEOUT_MS = 10;
 };
 

src/AlfServer.cxx

@@ -342,6 +342,8 @@ std::pair<Swt::Operation, Swt::Data> AlfServer::stringToSwtPair(const std::strin
       BOOST_THROW_EXCEPTION(
         AlfException() << ErrorInfo::Message("Too many arguments for RESET operation"));
     }
+  } else if (swtPair[swtPair.size() - 1] == "wait") {
+    operation = Swt::Operation::Wait;
   } else {
     BOOST_THROW_EXCEPTION(std::out_of_range("Parameter for SWT operation unkown"));
   }
@@ -376,6 +378,12 @@ std::pair<Swt::Operation, Swt::Data> AlfServer::stringToSwtPair(const std::strin
     } catch (const std::exception& e) {
       BOOST_THROW_EXCEPTION(SwtException() << ErrorInfo::Message("SWT Read Timeout provided cannot be converted to int"));
     }
+  } else if (operation == Swt::Operation::Wait && swtPair.size() == 2) {
+    try {
+      data = std::stoi(swtPair[0]);
+    } catch (const std::exception& e) {
+      BOOST_THROW_EXCEPTION(SwtException() << ErrorInfo::Message("SWT WaitTime provided cannot be converted to int"));
+    }
   }
 
   return std::make_pair(operation, data);

src/Sca.cxx

@@ -324,7 +324,7 @@ std::string Sca::writeSequence(const std::vector<std::pair<Operation, Data>>& op
     if (operation == Operation::Command) {
       resultBuffer << data << "\n"; // "[cmd],[data]\n"
     } else if (operation == Operation::Wait) {
-      resultBuffer << data << "\n"; // "[time]\n"
+      resultBuffer << std::dec << data << "\n"; // "[time]\n"
     } else if (operation == Operation::Error) {
       resultBuffer << data; // "[error_msg]"
       Logger::get().err() << data << endm;

src/Swt.cxx

@@ -210,6 +210,16 @@ std::vector<std::pair<Swt::Operation, Swt::Data>> Swt::executeSequence(std::vect
       } else if (operation == Operation::Reset) {
         reset();
         ret.push_back({ Operation::Reset, {} });
+      } else if (operation == Operation::Wait) {
+        int waitTime;
+        try {
+          waitTime = boost::get<WaitTime>(data);
+        } catch (...) { // no timeout was provided
+          data = DEFAULT_SWT_WAIT_TIME_MS;
+          waitTime = boost::get<WaitTime>(data);
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(waitTime));
+        ret.push_back({ operation, waitTime });
       } else {
         BOOST_THROW_EXCEPTION(SwtException() << ErrorInfo::Message("SWT operation type unknown"));
       }
@@ -221,6 +231,8 @@ std::vector<std::pair<Swt::Operation, Swt::Data>> Swt::executeSequence(std::vect
         meaningfulMessage = (boost::format("SWT_SEQUENCE WRITE data=%s serialId=%s link=%d, error='%s'") % boost::get<SwtWord>(data) % mLink.serialId % mLink.linkId % e.what()).str();
       } else if (operation == Operation::Reset) {
         meaningfulMessage = (boost::format("SWT_SEQUENCE RESET serialId=%d link=%s, error='%s'") % mLink.serialId % mLink.linkId % e.what()).str();
+      } else if (operation == Operation::Wait) {
+        meaningfulMessage = (boost::format("SWT_SEQUENCE WAIT waitTime=%d serialId=%s link=%d error='%s'") % boost::get<WaitTime>(data) % mLink.serialId % mLink.linkId % e.what()).str();
       } else {
         meaningfulMessage = (boost::format("SWT_SEQUENCE UNKNOWN serialId=%d link=%s,  error='%s'") % mLink.serialId % mLink.linkId % e.what()).str();
       }
@@ -251,6 +263,8 @@ std::string Swt::writeSequence(std::vector<std::pair<Operation, Data>> sequence,
       resultBuffer << "0\n";
     } else if (operation == Operation::Reset) {
       /* DO NOTHING */
+    } else if (operation == Operation::Wait) {
+      resultBuffer << std::dec << data << "\n";
     } else if (operation == Operation::Error) {
       resultBuffer << data;
       Logger::get().err() << data << endm;