added SWT functions: read_multiple and set_read_timeout

Author: sy-c

README.md

@@ -126,19 +126,26 @@ It extends the `SCA_SEQUENCE` to add the following functionality:
     * `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)
+    * `read_multiple` with count prefix (e.g. `2,read_multiple`): read a number of words
+    * `set_read_timeout` to define default read TimeOut in milliseconds (for read and read_multiple operations). (e.g. `10,set_read_timeout`). Timeout argument is optional, in which case the default value is reset.
+
 * Returns:
   * Sequence of SWT output as follows:
     * `write` always retuns `0`
     * `read` returns the SWT words present in the CRU SWT FIFO
     * `sc_reset` returns nothing
     * `wait` returns time waited
     * `lock` returns nothing
-    
+    * `read_multiple` returns the SWT words present in the CRU SWT FIFO (for the number of read requested)
+    * `set_read_timeout` returns the new timeout
+
 * Example:
   * DIM input `sc_reset\n0x0000000000badc0ffee,write\nread\n0xbadf00d,write\n4,read`
   * DIM input (atomic) `lock\nsc_reset\n0x0000000000badc0ffee,write\nread\n0xbadf00d,write\n4,read`
   * DIM output `0\n0x0000000000badc0ffee\n0\n0x000000000000badf00d\n`
 
+  NB: when calling the service from DIM did client for testing, use double quotes around the full query string.
+
 ##### IC_SEQUENCE
 
 * Parameters:

include/Alf/Swt.h

@@ -59,6 +59,8 @@ class Swt : public ScBase
 
   /// Enum for the different SWT operation types
   enum Operation { Read,
+                   ReadMultiple,
+                   SetReadTimeout,
                    Write,
                    SCReset,
                    Wait,
@@ -90,6 +92,14 @@ class Swt : public ScBase
   /// \throws o2::alf::SwtException in case of no SWT words in FIFO, or timeout exceeded
   std::vector<SwtWord> read(SwtWord::Size wordSize = SwtWord::Size::Low, TimeOut msTimeOut = DEFAULT_SWT_TIMEOUT_MS);
 
+  /// Reads multiple SWT words
+  /// \param wordSize The size of the SWT words to be read
+  /// \param numberOfWords The number of SWT words to be read
+  /// \param msTimeOut Timeout of the read operation in ms
+  /// \return A vector of SWT words read
+  /// \throws o2::alf::SwtException in case of no SWT words in FIFO, or timeout exceeded
+  std::vector<SwtWord> readMultiple(SwtWord::Size wordSize = SwtWord::Size::Low, unsigned int numberOfWords = 1, TimeOut msTimeOut = DEFAULT_SWT_TIMEOUT_MS);
+
   /// Executes an SWT sequence
   /// \param sequence A vector of Operation and Data pairs
   /// \param lock Boolean enabling implicit locking
@@ -115,10 +125,11 @@ class Swt : public ScBase
   static Operation StringToSwtOperation(std::string op);
 
   static constexpr int DEFAULT_SWT_TIMEOUT_MS = 10;
+  static constexpr int DEFAULT_SWT_WAIT_TIME_MS = 3;
 
  private:
-  static constexpr int DEFAULT_SWT_WAIT_TIME_MS = 3;
   SwtWord::Size mSwtWordSize = SwtWord::Size::Low;
+  TimeOut readTimeout = DEFAULT_SWT_TIMEOUT_MS;
 };
 
 } // namespace alf

src/AlfServer.cxx

@@ -326,37 +326,65 @@ std::pair<Swt::Operation, Swt::Data> AlfServer::stringToSwtPair(const std::strin
   Swt::Operation operation;
   Swt::Data data;
 
-  if (swtPair[swtPair.size() - 1] == "lock") {
-    operation = Swt::Operation::Lock;
+  bool getIntParam = false;
+  int numberOfMandatoryParams = -1; // do not care about number of parameters
+
+  try {
+    operation = Swt::StringToSwtOperation(swtPair[swtPair.size() - 1]);
+  } catch(...) {
+    BOOST_THROW_EXCEPTION(std::out_of_range("SWT unkown operation " + swtPair[swtPair.size() - 1]));
+  }
+
+  switch(operation) {
+    case Swt::Operation::Lock:
+      data = 0;
+      getIntParam = true;
+      break;
+    case Swt::Operation::SetReadTimeout:
+      data = Swt::DEFAULT_SWT_TIMEOUT_MS;
+      getIntParam = true;
+      break;
+    case Swt::Operation::Read:
+      getIntParam = true;
+      break;
+    case Swt::Operation::ReadMultiple:
+      getIntParam = true;
+      numberOfMandatoryParams = 1;
+      break;
+    case Swt::Operation::Write:
+      numberOfMandatoryParams = 1;
+      break;
+    case Swt::Operation::SCReset:
+      numberOfMandatoryParams = 0;
+      break;
+    case Swt::Operation::Wait:
+      data = Swt::DEFAULT_SWT_WAIT_TIME_MS;
+      getIntParam = true;
+      break;
+    default:
+      BOOST_THROW_EXCEPTION(std::out_of_range("Parameter for SWT operation unkown"));
+  }
+
+  // check number of mandatory parameters, if set
+  if (numberOfMandatoryParams >= 0) {
+      if (((int)swtPair.size() - 1) != numberOfMandatoryParams) {
+      BOOST_THROW_EXCEPTION(
+        AlfException() << ErrorInfo::Message("SWT wrong number of arguments for " + Swt::SwtOperationToString(operation) + " operation"));
+    }
+  }
+
+  // get int parameter if needed, and available
+  if (getIntParam) {
     if (swtPair.size() == 2) {
       try {
         data = std::stoi(swtPair[0]);
       } catch (const std::exception& e) {
-        BOOST_THROW_EXCEPTION(SwtException() << ErrorInfo::Message("SWT lock WaitTime provided cannot be converted to int"));
+        BOOST_THROW_EXCEPTION(SwtException() << ErrorInfo::Message("SWT " + Swt::SwtOperationToString(operation) + " argument provided cannot be converted to int"));
       }
-    } else {
-      data = 0;
     }
-  } else if (swtPair[swtPair.size() - 1] == "read") {
-    operation = Swt::Operation::Read;
-  } else if (swtPair[swtPair.size() - 1] == "write") {
-    operation = Swt::Operation::Write;
-    if (swtPair.size() == 1) {
-      BOOST_THROW_EXCEPTION(
-        AlfException() << ErrorInfo::Message("Too few arguments for WRITE operation"));
-    }
-  } else if (swtPair[swtPair.size() - 1] == "sc_reset") {
-    operation = Swt::Operation::SCReset;
-    if (swtPair.size() == 2) {
-      BOOST_THROW_EXCEPTION(
-        AlfException() << ErrorInfo::Message("Too many arguments for SC 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"));
   }
 
+  // special handling of the write parameter
   if (operation == Swt::Operation::Write) {
     SwtWord word;
     word.setSize(swtWordSize);
@@ -369,7 +397,7 @@ std::pair<Swt::Operation, Swt::Data> AlfServer::stringToSwtPair(const std::strin
     }
 
     if (hexString.length() > 19) {
-      BOOST_THROW_EXCEPTION(std::out_of_range("Parameter does not fit in 76-bit unsigned int"));
+      BOOST_THROW_EXCEPTION(std::out_of_range("SWT write argument does not fit in 76-bit unsigned int"));
     }
 
     std::stringstream ss;
@@ -380,18 +408,6 @@ std::pair<Swt::Operation, Swt::Data> AlfServer::stringToSwtPair(const std::strin
     word.setLow(std::stoul(ss.str().substr(11, 8), NULL, 16));
 
     data = word;
-  } else if (operation == Swt::Operation::Read && swtPair.size() == 2) {
-    try {
-      data = std::stoi(swtPair[0]);
-    } 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/Swt.cxx

@@ -104,6 +104,52 @@ std::vector<SwtWord> Swt::read(SwtWord::Size wordSize, TimeOut msTimeOut)
   return words;
 }
 
+std::vector<SwtWord> Swt::readMultiple(SwtWord::Size wordSize, unsigned int wordsToRead, TimeOut msTimeOut)
+{
+ checkChannelSet();
+
+ std::vector<SwtWord> words;
+ unsigned int readWords = 0x0;
+
+ while (readWords < wordsToRead) {
+   uint32_t numWords = 0x0;
+
+   auto timeOut = std::chrono::steady_clock::now() + std::chrono::milliseconds(msTimeOut);
+   bool isTimeout = false;
+   while (!isTimeout && (numWords < 1)) {
+     numWords = (barRead(sc_regs::SWT_MON.index) >> 16);
+     isTimeout = std::chrono::steady_clock::now() > timeOut;
+   }
+   if(isTimeout){
+     break;
+   }
+
+   for (int i = 0; i < (int)numWords; i++) {
+     SwtWord tempWord;
+
+     tempWord.setLow(barRead(sc_regs::SWT_RD_WORD_L.index));
+
+     if (wordSize == SwtWord::Size::Medium || wordSize == SwtWord::Size::High) {
+       tempWord.setMed(barRead(sc_regs::SWT_RD_WORD_M.index));
+     }
+
+     if (wordSize == SwtWord::Size::High) {
+       tempWord.setHigh(barRead(sc_regs::SWT_RD_WORD_H.index));
+     }
+
+     words.push_back(tempWord);
+   }
+   readWords += numWords;
+ }
+
+ if (readWords != wordsToRead) {
+     BOOST_THROW_EXCEPTION(SwtException() <<
+       ErrorInfo::Message("ReadMultiple different number of words than expected: " + std::to_string(readWords) + " (expected " + std::to_string(wordsToRead) + ")"));
+ }
+
+ return words;
+}
+
 void Swt::write(const SwtWord& swtWord)
 {
   checkChannelSet();
@@ -122,6 +168,7 @@ void Swt::write(const SwtWord& swtWord)
 
 std::vector<std::pair<Swt::Operation, Swt::Data>> Swt::executeSequence(std::vector<std::pair<Operation, Data>> sequence, bool lock, int lockTimeout)
 {
+
   if (lock) {
     mLlaSession->start(lockTimeout);
   }
@@ -143,22 +190,32 @@ std::vector<std::pair<Swt::Operation, Swt::Data>> Swt::executeSequence(std::vect
         try {
           timeOut = boost::get<TimeOut>(data);
         } catch (...) { // no timeout was provided
-          data = DEFAULT_SWT_TIMEOUT_MS;
+          data = readTimeout;
           timeOut = boost::get<TimeOut>(data);
         }
         auto results = read(mSwtWordSize, timeOut);
 
         for (const auto& result : results) {
-          ret.push_back({ Operation::Read, result });
+          ret.push_back({ operation, result });
         }
+      } else if (operation == Operation::ReadMultiple) {
+        int count;
+        count = boost::get<int>(data);
+        auto results = readMultiple(mSwtWordSize, count, readTimeout);
+        for (const auto& result : results) {
+          ret.push_back({ operation, result });
+        }
+      } else if (operation == Operation::SetReadTimeout) {
+        readTimeout = boost::get<TimeOut>(data);
+        ret.push_back({ operation, readTimeout });
       } else if (operation == Operation::Write) {
         SwtWord word = boost::get<SwtWord>(data);
         write(word);
-        ret.push_back({ Operation::Write, word });
+        ret.push_back({ operation, word });
         //ret.push_back({ Operation::Write, {} }); // TODO: Is it better to return {} ?
       } else if (operation == Operation::SCReset) {
         scReset();
-        ret.push_back({ Operation::SCReset, {} });
+        ret.push_back({ operation, {} });
       } else if (operation == Operation::Wait) {
         int waitTime;
         try {
@@ -208,6 +265,10 @@ std::string Swt::writeSequence(std::vector<std::pair<Operation, Data>> sequence,
     Data data = it.second;
     if (operation == Operation::Read) {
       resultBuffer << data << "\n";
+    } else if (operation == Operation::ReadMultiple) {
+      resultBuffer << data << "\n";
+    } else if (operation == Operation::SetReadTimeout) {
+      resultBuffer << std::dec << data << "\n";
     } else if (operation == Operation::Write) {
       resultBuffer << "0\n";
     } else if (operation == Operation::SCReset) {
@@ -231,6 +292,10 @@ std::string Swt::SwtOperationToString(Swt::Operation op)
 {
   if (op == Swt::Operation::Read) {
     return "read";
+  } else if (op == Swt::Operation::ReadMultiple) {
+    return "read_multiple";
+  } else if (op == Swt::Operation::SetReadTimeout) {
+    return "set_read_timeout";
   } else if (op == Swt::Operation::Write) {
     return "write";
   } else if (op == Swt::Operation::SCReset) {
@@ -250,6 +315,10 @@ Swt::Operation Swt::StringToSwtOperation(std::string op)
 {
   if (op == "read") {
     return Swt::Operation::Read;
+  } else if (op == "read_multiple") {
+    return Swt::Operation::ReadMultiple;
+  } else if (op == "set_read_timeout") {
+    return Swt::Operation::SetReadTimeout;
   } else if (op == "write") {
     return Swt::Operation::Write;
   } else if (op == "sc_reset") {