SWT and client changes

* [swt] Update interface

* [alf-client] Add option for ALF server hostname

* [swt] Always truncate word to 76bits

Author: kostorr

apps/ProgramAlfClient.cxx

@@ -59,10 +59,17 @@ class ProgramAlfClient : public AliceO2::Common::Program
     options.add_options()("link",
                           po::value<int>(&mOptions.link),
                           "Link number");
+    options.add_options()("alf-id",
+                          po::value<std::string>(&mOptions.alfId)->default_value(""),
+                          "Hostname of node running the ALF server(required)");
   }
 
   virtual void run(const po::variables_map&) override
   {
+    if (mOptions.alfId == "") {
+      getErrorLogger() << "Parameter alf-id is required." << endm;
+      return;
+    }
 
     getLogger() << "ALF client initializations..." << endm;
 
@@ -77,7 +84,7 @@ class ProgramAlfClient : public AliceO2::Common::Program
       BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("DIM_DNS_NODE env variable not set, and no relevant argument provided.")); // InfoLogger and errors?
     }
 
-    std::string alfId = ip::host_name();
+    std::string alfId = mOptions.alfId; //TODO: change to hostname argument
     boost::to_upper(alfId);
 
     getLogger() << "Starting the DIM Client using ALF ID=" << alfId << ", serial=" << mOptions.serial << " and link=" << mOptions.link << endm;
@@ -100,9 +107,10 @@ class ProgramAlfClient : public AliceO2::Common::Program
     uint32_t rValue = registerReadRpc.readRegister(rAddress);
     getWarningLogger() << "Wrote: " << Util::formatValue(wValue) << " Read: " << Util::formatValue(rValue) << endm;
 
-    auto swtOut = swtSequence.write({ std::make_pair("0x00000000000000000000", "write"),
+    auto swtOut = swtSequence.write({ std::make_pair("0x0000000000000000000", "write"),
+                                      std::make_pair("", "reset"),
                                       std::make_pair("0x000000001234", "write"),
-                                      std::make_pair("0x0", "read") });
+                                      std::make_pair("", "read") });
     getWarningLogger() << "swtSequence output: " << swtOut << endm;
 
     auto scaOut = scaSequence.write({ std::make_pair("0x00010002", "0xff000000"),
@@ -134,6 +142,7 @@ class ProgramAlfClient : public AliceO2::Common::Program
     std::string dimDnsNode = "";
     int serial = -1;
     int link = -1;
+    std::string alfId = "";
   } mOptions;
 };
 

src/AlfClient.h

@@ -136,7 +136,11 @@ class SwtSequenceRpc : DimRpcInfoWrapper
   {
     std::stringstream buffer;
     for (size_t i = 0; i < sequence.size(); ++i) {
-      buffer << sequence[i].first << pairSeparator() << sequence[i].second;
+      if (sequence[i].first != "") {
+        buffer << sequence[i].first << pairSeparator() << sequence[i].second;
+      } else {
+        buffer << sequence[i].second;
+      }
       if (i + 1 < sequence.size()) {
         buffer << argumentSeparator();
       }

src/AlfServer.cxx

@@ -116,39 +116,55 @@ Sca::CommandData AlfServer::stringToScaPair(std::string stringPair)
 std::pair<SwtWord, Swt::Operation> AlfServer::stringToSwtPair(const std::string stringPair)
 {
   std::vector<std::string> swtPair = Util::split(stringPair, pairSeparator());
-  if (swtPair.size() != 2) {
+  if (swtPair.size() != 1 && swtPair.size() != 2) {
     BOOST_THROW_EXCEPTION(
       AlfException() << ErrorInfo::Message("SWT word pair not formatted correctly"));
   }
 
-  std::string hexString = swtPair[0];
-  std::string leadingHex = "0x";
+  Swt::Operation operation;
 
-  std::string::size_type i = hexString.find(leadingHex);
-  if (i != std::string::npos) {
-    hexString.erase(i, leadingHex.size());
+  if (swtPair[swtPair.size() - 1] == "read") {
+    operation = Swt::Operation::Read;
+    if (swtPair.size() == 2) {
+      BOOST_THROW_EXCEPTION(
+        AlfException() << ErrorInfo::Message("Too many arguments for READ operation"));
+    }
+  } 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] == "reset") {
+    operation = Swt::Operation::Reset;
+    if (swtPair.size() == 2) {
+      BOOST_THROW_EXCEPTION(
+        AlfException() << ErrorInfo::Message("Too many arguments for RESET operation"));
+    }
+  } else {
+    BOOST_THROW_EXCEPTION(std::out_of_range("Parameter for SWT operation unkown"));
   }
 
-  if (hexString.length() > 19) {
-    BOOST_THROW_EXCEPTION(std::out_of_range("Parameter does not fit in 76-bit unsigned int"));
-  }
+  SwtWord word;
+  if (operation == Swt::Operation::Write) {
+    std::string hexString = swtPair[0];
+    std::string leadingHex = "0x";
 
-  std::stringstream ss;
-  ss << std::setw(19) << std::setfill('0') << hexString;
+    std::string::size_type i = hexString.find(leadingHex);
+    if (i != std::string::npos) {
+      hexString.erase(i, leadingHex.size());
+    }
 
-  SwtWord word;
-  word.setHigh(std::stoul(ss.str().substr(0, 3), NULL, 16));
-  word.setMed(std::stoul(ss.str().substr(3, 8), NULL, 16));
-  word.setLow(std::stoul(ss.str().substr(11, 8), NULL, 16));
+    if (hexString.length() > 19) {
+      BOOST_THROW_EXCEPTION(std::out_of_range("Parameter does not fit in 76-bit unsigned int"));
+    }
 
-  Swt::Operation operation;
+    std::stringstream ss;
+    ss << std::setw(19) << std::setfill('0') << hexString;
 
-  if (swtPair[1] == "read") {
-    operation = Swt::Operation::Read;
-  } else if (swtPair[1] == "write") {
-    operation = Swt::Operation::Write;
-  } else {
-    BOOST_THROW_EXCEPTION(std::out_of_range("Parameter for SWT operation unkown"));
+    word.setHigh(std::stoul(ss.str().substr(0, 3), NULL, 16));
+    word.setMed(std::stoul(ss.str().substr(3, 8), NULL, 16));
+    word.setLow(std::stoul(ss.str().substr(11, 8), NULL, 16));
   }
 
   return std::make_pair(word, operation);

src/Swt/Swt.cxx

@@ -41,7 +41,6 @@ namespace sc_regs = AliceO2::roc::Cru::ScRegisters;
 
 Swt::Swt(AlfLink link) : mBar2(*link.bar2), mLink(link)
 {
-  reset();
   setChannel(mLink.linkId);
 }
 
@@ -128,12 +127,15 @@ std::string Swt::writeSequence(std::vector<std::pair<SwtWord, Operation>> words)
       if (it.second == Operation::Read) {
         std::vector<SwtWord> results;
         read(results);
-        for (const auto& word : results) {
-          resultBuffer << word << "\n";
+        for (const auto& result : results) {
+          resultBuffer << result << "\n";
         }
       } else if (it.second == Operation::Write) {
         write(word);
-        resultBuffer << word << "\n";
+        resultBuffer << "0"
+                     << "\n";
+      } else if (it.second == Operation::Reset) {
+        reset();
       } else {
         BOOST_THROW_EXCEPTION(SwtException() << ErrorInfo::Message("SWT operation type unknown"));
       }

src/Swt/Swt.h

@@ -50,7 +50,8 @@ class Swt
   void read(std::vector<SwtWord>& words, SwtWord::Size wordSize = SwtWord::Size::High);
 
   enum Operation { Read,
-                   Write };
+                   Write,
+                   Reset };
 
   std::string writeSequence(std::vector<std::pair<SwtWord, Operation>> words);
 

src/Swt/SwtWord.cxx

@@ -75,7 +75,7 @@ void SwtWord::setMed(uint32_t med)
 
 void SwtWord::setHigh(uint16_t high)
 {
-  mHigh = high;
+  mHigh = high & 0xfff;
 }
 
 uint32_t SwtWord::getLow() const
@@ -90,7 +90,7 @@ uint32_t SwtWord::getMed() const
 
 uint16_t SwtWord::getHigh() const
 {
-  return mHigh;
+  return mHigh & 0xfff;
 }
 
 std::ostream& operator<<(std::ostream& output, const SwtWord& swtWord)