ALF: Add SCA_WRITE_SEQUENCE RPC service

Author: PascalBoeschoten

src/CommandLineUtilities/AliceLowlevelFrontend/AliceLowlevelFrontend.h

@@ -52,6 +52,12 @@ inline void setDataString(const std::string& string, DimObject& dimObject, bool
   dimObject.setData(buffer.data(), buffer.size());
 }
 
+template <typename DimObject>
+inline void setDataBuffer(std::vector<char>& buffer, DimObject& dimObject)
+{
+  dimObject.setData(buffer.data(), buffer.size());
+}
+
 inline std::string successPrefix()
 {
   return "success:";
@@ -98,7 +104,7 @@ class DimRpcInfoWrapper
     {
     }
 
-    void setString(std::string string)
+    void setString(const std::string& string)
     {
       setDataString(string, getDimRpcInfo());
     }
@@ -113,6 +119,15 @@ class DimRpcInfoWrapper
       return string;
     }
 
+    template <typename T>
+    std::vector<T> getBlob()
+    {
+      auto data = reinterpret_cast<T*>(mRpcInfo->getData());
+      auto size = mRpcInfo->getSize();
+      std::vector<T> buffer(data, data + (size / sizeof(T)));
+      return buffer;
+    }
+
     DimRpcInfo& getDimRpcInfo() const {
       return *mRpcInfo.get();
     }
@@ -171,8 +186,8 @@ class RegisterReadRpc: DimRpcInfoWrapper
 
     uint32_t readRegister(uint64_t registerAddress)
     {
-      setString((boost::format("%u") % registerAddress).str());
-      return boost::lexical_cast<uint32_t>(stripPrefix(getString()));
+      setString((boost::format("0x%x") % registerAddress).str());
+      return convertHexString(stripPrefix(getString()));
     }
 };
 
@@ -186,22 +201,7 @@ class RegisterWriteRpc: DimRpcInfoWrapper
 
     void writeRegister(uint64_t registerAddress, uint32_t registerValue)
     {
-      setString((boost::format("%u,%u") % registerAddress % registerValue).str());
-      getString();
-    }
-};
-
-class RegisterWriteBlockRpc: DimRpcInfoWrapper
-{
-  public:
-    RegisterWriteBlockRpc(const std::string& serviceName)
-        : DimRpcInfoWrapper(serviceName)
-    {
-    }
-
-    void writeRegister(uint64_t registerAddress, uint32_t registerValue)
-    {
-      setString((boost::format("%u,%u") % registerAddress % registerValue).str());
+      setString((boost::format("0x%x,0x%x") % registerAddress % registerValue).str());
       getString();
     }
 };
@@ -266,6 +266,32 @@ class ScaGpioReadRpc: DimRpcInfoWrapper
     }
 };
 
+class ScaWriteSequence: DimRpcInfoWrapper
+{
+  public:
+    ScaWriteSequence(const std::string& serviceName)
+      : DimRpcInfoWrapper(serviceName)
+    {
+    }
+
+    std::string write(const std::string& buffer)
+    {
+      setString(buffer);
+      return getString();
+    }
+
+    std::string write(const std::vector<std::pair<uint32_t, uint32_t>>& sequence)
+    {
+      std::stringstream buffer;
+      for (size_t i = 0; i < sequence.size(); ++i) {
+        buffer << sequence[i].first << ',' << sequence[i].second;
+        if (i + 1 < sequence.size()) {
+          buffer << ';';
+        }
+      }
+      return write(buffer.str());
+    }
+};
 
 class StringRpcServer: public DimRpc
 {

src/CommandLineUtilities/AliceLowlevelFrontend/ProgramAliceLowlevelFrontendClient.cxx

@@ -71,6 +71,7 @@ class ProgramAliceLowlevelFrontendClient: public Program
       Alf::ScaWriteRpc scaWriteRpc(names.scaWrite());
       Alf::ScaGpioReadRpc scaGpioReadRpc(names.scaGpioRead());
       Alf::ScaGpioWriteRpc scaGpioWriteRpc(names.scaGpioWrite());
+      Alf::ScaWriteSequence scaWriteSequence(names.scaWriteSequence());
       Alf::PublishRpc publishRpc(names.publishStartCommandRpc());
 
       publishRpc.publish("ALF/TEST/1", 1.0, {0x1fc});
@@ -83,21 +84,29 @@ class ProgramAliceLowlevelFrontendClient: public Program
         cout << "  result: " << scaGpioReadRpc.read() << endl;
       }
 
-//      for (int i = 0; i < 10; ++i) {
-//        auto transactionId = i + 0x10000;
-//        cout << "SCA write" << endl;
-//        cout << "  result: " << scaWriteRpc.write(0xffff + transactionId, i) << endl;
-//        cout << "SCA read" << endl;
-//        cout << "  result: " << scaReadRpc.read() << endl;
-//      }
-
-      cout << "1k writes to 0x1fc..." << endl;
-      for (int i = 0; i < 1000; ++i) {
-        readRpc.readRegister(0x1fc);
+      {
+        cout << "1k writes to 0x1fc..." << endl;
+        for (int i = 0; i < 1000; ++i) {
+          readRpc.readRegister(0x1fc);
+        }
+        cout << "Done!" << endl;
+      }
+
+      {
+        size_t numInts = 4;
+        cout << "Writing blob of " << numInts << " pairs of 32-bit ints..." << endl;
+        std::vector<std::pair<uint32_t, uint32_t>> buffer(numInts);
+        for (size_t i = 0; i < buffer.size(); ++i) {
+          buffer[i] = {i * 2, i * 2 + 1};
+        }
+
+        std::string result = scaWriteSequence.write(buffer);
+        cout << "Done!" << endl;
+        cout << "Got result: \n";
+        cout << "  " << result << '\n';
       }
-      cout << "Done!" << endl;
 
-      while (!isSigInt())
+      while (false)//!isSigInt())
       {
         cout << "-------------------------------------\n";
         cout << "Temperature   = " << gTemperature << endl;

src/CommandLineUtilities/AliceLowlevelFrontend/ProgramAliceLowlevelFrontendServer.cxx

@@ -12,12 +12,14 @@
 #include <mutex>
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/tokenizer.hpp>
 #include <boost/variant.hpp>
 #include <InfoLogger/InfoLogger.hxx>
 #include <dim/dis.hxx>
 #include "AliceLowlevelFrontend.h"
 #include "AlfException.h"
 #include "folly/ProducerConsumerQueue.h"
+#include "Utilities/Util.h"
 #include "ReadoutCard/Parameters.h"
 #include "ReadoutCard/ChannelFactory.h"
 #include "Sca.h"
@@ -243,6 +245,8 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
         [&](auto parameter){return scaRead(parameter, bar2);});
       auto serverScaWrite = makeServer(names.scaWrite(),
         [&](auto parameter){return scaWrite(parameter, bar2);});
+      auto serverScaWriteSequence = makeServer(names.scaWriteSequence(),
+        [&](auto parameter){return scaBlobWrite(parameter, bar2);});
       auto serverScaGpioRead = makeServer(names.scaGpioRead(),
         [&](auto parameter){return scaGpioRead(parameter, bar2);});
       auto serverScaGpioWrite = makeServer(names.scaGpioWrite(),
@@ -287,14 +291,14 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
     /// RPC handler for register reads
     static std::string registerRead(const std::string& parameter, ChannelSharedPtr channel)
     {
-      auto address = b::lexical_cast<uint64_t>(parameter);
+      auto address = convertHexString(parameter);
       checkAddress(address);
 
       uint32_t value = channel->readRegister(address / 4);
 
       // getInfoLogger() << "READ   " << Common::makeRegisterString(address, value) << endm;
 
-      return std::to_string(value);
+      return (b::format("0x%x") % value).str();
     }
 
     /// RPC handler for register writes
@@ -306,8 +310,8 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
         BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Write RPC call did not have 2 parameters"));
       }
 
-      auto address = b::lexical_cast<uint64_t>(params[0]);
-      auto value = b::lexical_cast<uint32_t>(params[1]);
+      auto address = convertHexString(params[0]);;
+      auto value = convertHexString(params[1]);;
       checkAddress(address);
 
       // getInfoLogger() << "WRITE  " << Common::makeRegisterString(address, value) << endm;
@@ -354,7 +358,7 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
     {
       getInfoLogger() << "SCA_READ" << endm;
       auto result = Sca(*bar2, bar2->getCardType()).read();
-      return (b::format("0x%x,0x%x") % result.data % result.command).str();
+      return (b::format("0x%x,0x%x") % result.command % result.data).str();
     }
 
     static std::string scaWrite(const std::string& parameter, ChannelSharedPtr bar2)
@@ -382,6 +386,37 @@ class ProgramAliceLowlevelFrontendServer: public AliceO2::Common::Program
       return "";
     }
 
+    static std::string scaBlobWrite(const std::string& parameter, ChannelSharedPtr bar2)
+    {
+      getInfoLogger() << "SCA_BLOB_WRITE size=" << parameter.size() << " bytes" << endm;
+
+      // We first split on ; to get the pairs of SCA command and SCA data
+      // Since this can be an enormous list of pairs, we walk through it using the tokenizer
+      auto commandDataPairs = split(parameter, ";");
+      using tokenizer = boost::tokenizer<boost::char_separator<char>>;
+      boost::char_separator<char> sep(";", "", boost::drop_empty_tokens); // Drop ";" delimiters, keep none
+      std::stringstream resultBuffer;
+      auto sca = Sca(*bar2, bar2->getCardType());
+      for (std::string token : tokenizer(parameter, sep)) {
+        // Walk through the tokens, these should be the pairs. The pairs are comma-separated, so we split those.
+        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]);
+        sca.write(command, data);
+        auto result = sca.read();
+        getInfoLogger() << (b::format("cmd=0x%x data=0x%x result=0x%x") % command % data % result.data).str() << endm;
+        resultBuffer << std::hex << result.data << ';';
+      }
+      auto result = resultBuffer.str();
+      if (result.size() > 0) {
+        result.pop_back(); // Pop the last ';'
+      }
+      return result;
+    }
+
     int mSerialNumber = 0;
     CommandQueue mCommandQueue;
     double mTemperature = 40;

src/CommandLineUtilities/AliceLowlevelFrontend/README.md

@@ -17,9 +17,10 @@ Some of the services are RPC calls.
 * When the argument must contain multiple values, they must be comma-separated.
 * The return string will contain an 8-byte prefix indicating success or failure "success:" or "failure:",
   optionally followed by a return value or error message.
-* Numbers and addresses are all in base-10.
+* Numbers and addresses are all in base-16. A '0x' prefix for numbers is accepted, but unnecessary for the parameters. 
+  The '0x' prefix is omitted for return values.
 
-For example: a register write call could have the argument string "504,42" meaning write value 42 to address 504.
+For example: a register write call could have the argument string "0x504,0x4" meaning write value 0x42 to address 0x4.
 The return string could be "success:" or "failure:Address out of range".
 
 ## Service description
@@ -41,15 +42,38 @@ A basic read from the SCA
 * Service type: RPC call
 * Service name: SCA_READ
 * Parameters: empty
-* Return: SCA data, SCA command
+* Return: SCA command, SCA data
 
 #### SCA write
 A basic write to the SCA
 * Service type: RPC call
 * Service name: SCA_WRITE
-* Parameters: SCA data, SCA command
+* Parameters: SCA command, SCA data
 * Return: empty
 
+#### SCA write sequence
+Write a sequence of values to the SCA
+* Service type: RPC call
+* Service name: SCA_SEQUENCE_WRITE
+* Parameters: A sequence of pairs of SCA command and data. The pairs are separated by semicolon, the command and data by 
+    comma: 
+    ~~~
+    [command 0],[data 0];[command 1],[data 1]; ... 
+    ~~~
+    For example:
+    ~~~
+    10,11;20,21;30,31
+    ~~~
+* Return: A sequence of SCA read return values corresponding to the commands from the input sequence:
+    ~~~
+    [value 0];[value 1]; ...
+    ~~~
+    For example:
+    ~~~
+    42;123;555
+    ~~~
+    
+
 #### SCA GPIO read
 Read the GPIO pins
 * Service type: RPC call

src/CommandLineUtilities/AliceLowlevelFrontend/Sca.cxx

@@ -71,7 +71,7 @@ auto Sca::read() -> ReadResult
   auto command = barRead(Registers::READ_COMMAND);
 //  printf("Sca::read   DATA=0x%x   CH=0x%x   TR=0x%x   CMD=0x%x\n", data, command >> 24, (command >> 16) & 0xff, command & 0xff);
   checkError(command);
-  return { data, command };
+  return { command, data };
 }
 
 void Sca::checkError(uint32_t command)

src/CommandLineUtilities/AliceLowlevelFrontend/Sca.h

@@ -28,8 +28,8 @@ class Sca
 
     struct ReadResult
     {
-        uint32_t data;
         uint32_t command;
+        uint32_t data;
     };
 
     Sca(RegisterReadWriteInterface& bar2, CardType::type cardType);

src/CommandLineUtilities/AliceLowlevelFrontend/ServiceNames.cxx

@@ -23,6 +23,7 @@ DEFSERVICENAME(publishStartCommandRpc, "PUBLISH_SERVICE")
 DEFSERVICENAME(publishStopCommandRpc, "PUBLISH_SERVICE_STOP")
 DEFSERVICENAME(scaRead, "SCA_READ")
 DEFSERVICENAME(scaWrite, "SCA_WRITE")
+DEFSERVICENAME(scaWriteSequence, "SCA_WRITE_SEQUENCE")
 DEFSERVICENAME(scaGpioWrite, "SCA_GPIO_WRITE")
 DEFSERVICENAME(scaGpioRead, "SCA_GPIO_READ")
 DEFSERVICENAME(temperature, "TEMPERATURE")

src/CommandLineUtilities/AliceLowlevelFrontend/ServiceNames.h

@@ -26,6 +26,7 @@ class ServiceNames
     std::string publishStartCommandRpc() const;
     std::string publishStopCommandRpc() const;
     std::string scaWrite() const;
+    std::string scaWriteSequence() const;
     std::string scaRead() const;
     std::string scaGpioWrite() const;
     std::string scaGpioRead() const;