Improved SCA publish

Author: PascalBoeschoten

src/CommandLineUtilities/AliceLowlevelFrontend/ProgramAliceLowlevelFrontendServer.cxx

@@ -83,12 +83,12 @@ struct ServiceDescription
         std::vector<uintptr_t> addresses;
     };
 
-    struct Sca
+    struct ScaSequence
     {
-        std::vector<std::pair<uint32_t, uint32_t>> commandDataPairs;
+        std::vector<Sca::CommandData> commandDataPairs;
     };
 
-    boost::variant<Register, Sca> type;
+    boost::variant<Register, ScaSequence> type;
 };
 
 /// Class that handles adding/removing publishers
@@ -151,8 +151,8 @@ class PublisherRegistry
                 << type.addresses.size() << " address(es) at interval "
                 << mDescription.interval.count() << "ms" << endm;
             },
-            [&](const ServiceDescription::Sca& type){
-              registerValues.resize(1); // SCA publisher only publishes 1 value
+            [&](const ServiceDescription::ScaSequence& type){
+              registerValues.resize(type.commandDataPairs.size() * 2); // Two result 32-bit integers per pair
 
               getInfoLogger() << "Starting SCA publisher '" << mDescription.dnsName << "' with "
                 << type.commandDataPairs.size() << " commands(s) at interval "
@@ -183,17 +183,14 @@ class PublisherRegistry
                 registerValues.at(i) = channel.readRegister(index);
               }
             },
-            [&](const ServiceDescription::Sca& type){
+            [&](const ServiceDescription::ScaSequence& type){
               auto sca = Sca(channel, channel.getCardType());
-
               for (size_t i = 0; i < type.commandDataPairs.size(); ++i) {
                 const auto& pair = type.commandDataPairs[i];
-                sca.write(pair.first, pair.second);
-                if (i+1 == type.commandDataPairs.size()) {
-                  // Last one, we do a read. This result is published.
-                  auto result = sca.read();
-                  registerValues.at(0) = channel.readRegister(result.data);
-                }
+                sca.write(pair);
+                auto result = sca.read();
+                registerValues[i*2] = result.command;
+                registerValues[i*2 + 1] = result.data;
               }
             }
           );
@@ -296,6 +293,8 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
         [&](auto parameter){return registerWrite(parameter, bar0);});
       auto serverPublishStart = makeServer(names.publishStartCommandRpc(),
         [&](auto parameter){return publishStartCommand(parameter, mCommandQueue);});
+      auto serverPublishScaStart = makeServer(names.publishScaStartCommandRpc(),
+        [&](auto parameter){return publishScaStartCommand(parameter, mCommandQueue);});
       auto serverPublishStop = makeServer(names.publishStopCommandRpc(),
         [&](auto parameter){return publishStopCommand(parameter, mCommandQueue);});
       auto serverScaRead = makeServer(names.scaRead(),
@@ -347,6 +346,16 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
       }
     }
 
+    /// Try to add a command to the queue
+    static bool tryAddToQueue(const CommandVariant& command, CommandQueue& queue)
+    {
+      if (!queue.write(command)) {
+        getInfoLogger() << "  command queue was full!" << endm;
+        return false;
+      }
+      return true;
+    }
+
     /// RPC handler for register reads
     static std::string registerRead(const std::string& parameter, ChannelSharedPtr channel)
     {
@@ -387,7 +396,7 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
     }
 
     /// RPC handler for publish commands
-    static std::string publishStartCommand(const std::string& parameter, CommandQueue& commandQueue)
+    static std::string publishStartCommand(const std::string& parameter, CommandQueue& queue)
     {
       getInfoLogger() << "Received publish command: '" << parameter << "'" << endm;
       auto params = split(parameter, ";");
@@ -397,19 +406,39 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
       description.dnsName = params.at(0);
       description.interval = std::chrono::milliseconds(int64_t(b::lexical_cast<double>(params.at(2)) * 1000.0));
 
-      if (!commandQueue.write(CommandPublishStart{std::move(description)})) {
-        getInfoLogger() << "  command queue was full!" << endm;
+      tryAddToQueue(CommandPublishStart{description}, queue);
+      return "";
+    }
+
+    /// RPC handler for SCA publish commands
+    static std::string publishScaStartCommand(const std::string& parameter, CommandQueue& queue)
+    {
+      getInfoLogger() << "Received SCA publish command: '" << parameter << "'" << endm;
+
+      auto params = split(parameter, ";");
+
+      // Convert command-data pair string sequence to binary format
+      ServiceDescription::ScaSequence sca;
+      auto commandDataPairStrings = split(params.at(1), "\n");
+      sca.commandDataPairs.resize(commandDataPairStrings.size());
+      for (size_t i = 0; i < commandDataPairStrings.size(); ++i) {
+        sca.commandDataPairs[i] = stringToScaCommandDataPair(commandDataPairStrings[i]);
       }
+
+      ServiceDescription description;
+      description.type = sca;
+      description.dnsName = params.at(0);
+      description.interval = std::chrono::milliseconds(int64_t(b::lexical_cast<double>(params.at(2)) * 1000.0));
+
+      tryAddToQueue(CommandPublishStart{description}, queue);
       return "";
     }
 
     /// RPC handler for publish stop commands
-    static std::string publishStopCommand(const std::string& parameter, CommandQueue& commandQueue)
+    static std::string publishStopCommand(const std::string& parameter, CommandQueue& queue)
     {
       getInfoLogger() << "Received stop command: '" << parameter << "'" << endm;
-      if (!commandQueue.write(CommandPublishStop{parameter})) {
-        getInfoLogger() << "  command queue was full!" << endm;
-      }
+      tryAddToQueue(CommandPublishStop{parameter}, queue);
       return "";
     }
 
@@ -461,26 +490,18 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
       std::stringstream resultBuffer;
       auto sca = Sca(*bar2, bar2->getCardType());
 
-      for (std::string token : tokenizer(parameter, sep)) {
+      for (const std::string& token : tokenizer(parameter, sep)) {
         // Walk through the tokens, these should be the pairs (or comments).
         if (token.find('#') == 0) {
           // We have a comment, skip this token
           continue;
         } else {
-          // The pairs are comma-separated, so we split them.
-          std::vector<std::string> pair = split(token, ",");
-          if (pair.size() != 2) {
-            BOOST_THROW_EXCEPTION(
-              AlfException() << ErrorInfo::Message("SCA command-data pair not formatted correctly"));
-          }
-          auto command = convertHexString(pair[0]);
-          auto data = convertHexString(pair[1]);
-
+          auto commandData = stringToScaCommandDataPair(token);
           try {
-            sca.write(command, data);
+            sca.write(commandData);
             auto result = sca.read();
-            getInfoLogger() << (b::format("cmd=0x%x data=0x%x result=0x%x") % command % data % result.data).str()
-              << endm;
+            getInfoLogger() << (b::format("cmd=0x%x data=0x%x result=0x%x") % commandData.command % commandData.data %
+              result.data).str() << endm;
             resultBuffer << std::hex << result.data << '\n';
           } catch (const ScaException &e) {
             // If an SCA error occurs, we stop executing the sequence of commands and return the results as far as we got
@@ -494,6 +515,20 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
       return resultBuffer.str();
     }
 
+    static Sca::CommandData stringToScaCommandDataPair(const std::string& string)
+    {
+      // The pairs are comma-separated, so we split them.
+      std::vector<std::string> pair = split(string, ",");
+      if (pair.size() != 2) {
+        BOOST_THROW_EXCEPTION(
+          AlfException() << ErrorInfo::Message("SCA command-data pair not formatted correctly"));
+      }
+      Sca::CommandData commandData;
+      commandData.command = convertHexString(pair[0]);
+      commandData.data = convertHexString(pair[1]);
+      return commandData;
+    };
+
     int mSerialNumber = 0;
     CommandQueue mCommandQueue;
     double mTemperature = 40;

src/CommandLineUtilities/AliceLowlevelFrontend/README.md

@@ -25,6 +25,30 @@ The return string could be "success:" or "failure:Address out of range".
 
 ## Service description
 
+#### Publish registers
+Starts a service under a DNS name, that publishes the contents of the given register addresses at the specified 
+interval.
+Values are published as array of 32 bit unsigned integers. 
+* Service type: RPC call
+* Service name: PUBLISH_START
+* Parameters: DNS name to publish at, comma-separated register addresses, interval in seconds
+* Return: empty
+
+#### Publish SCA
+Starts a service under a DNS name, that executes and publishes the results of the given SCA write sequence at the 
+specified interval. Values are published as array of 32 bit unsigned integers. 
+* Service type: RPC call
+* Service name: PUBLISH_SCA_START
+* Parameters: DNS name to publish at, comma-separated register addresses, interval in seconds
+* Return: empty
+
+#### Publish stop
+Stops a publishing service (either regular or SCA) registered under the given DNS name.
+* Service type: RPC call
+* Service name: PUBLISH_STOP
+* Parameters: DNS name
+* Return: empty
+
 #### Register read
 * Service type: RPC call
 * Service name: REGISTER_READ

src/CommandLineUtilities/AliceLowlevelFrontend/Sca.h

@@ -25,10 +25,20 @@ class Sca
         uint32_t data;
     };
 
+    struct CommandData
+    {
+        uint32_t command;
+        uint32_t data;
+    };
+
     Sca(RegisterReadWriteInterface& bar2, CardType::type cardType);
 
     void initialize();
     void write(uint32_t command, uint32_t data);
+    void write(CommandData commandData)
+    {
+        write(commandData.command, commandData.data);
+    }
     ReadResult read();
     ReadResult gpioRead();
     ReadResult gpioWrite(uint32_t data);

src/CommandLineUtilities/AliceLowlevelFrontend/ServiceNames.cxx

@@ -20,6 +20,7 @@ std::string ServiceNames::_function() const \
 DEFSERVICENAME(registerReadRpc, "REGISTER_READ")
 DEFSERVICENAME(registerWriteRpc, "REGISTER_WRITE")
 DEFSERVICENAME(publishStartCommandRpc, "PUBLISH_SERVICE")
+DEFSERVICENAME(publishScaStartCommandRpc, "PUBLISH_SCA_SERVICE")
 DEFSERVICENAME(publishStopCommandRpc, "PUBLISH_SERVICE_STOP")
 DEFSERVICENAME(scaRead, "SCA_READ")
 DEFSERVICENAME(scaWrite, "SCA_WRITE")

src/CommandLineUtilities/AliceLowlevelFrontend/ServiceNames.h

@@ -24,6 +24,7 @@ class ServiceNames
     std::string registerReadRpc() const;
     std::string registerWriteRpc() const;
     std::string publishStartCommandRpc() const;
+    std::string publishScaStartCommandRpc() const;
     std::string publishStopCommandRpc() const;
     std::string scaWrite() const;
     std::string scaWriteSequence() const;