Merge pull request #419 from sy-c/master

sy-c · web-flow · commit 062fa667b458 · 2023-10-03T11:15:59.000+02:00
pat-player
diff --git a/cmake/ReadoutCardConfig.cmake.in b/cmake/ReadoutCardConfig.cmake.in
@@ -20,14 +20,9 @@ set(Monitoring_CMAKE_DIR @Monitoring_DIR@)
 set(InfoLogger_CMAKE_DIR @InfoLogger_ROOT@)
 
 if(NOT APPLE)
-        find_package(Python3 3.6 COMPONENTS Interpreter Development)
+  find_package(Python3 3.6 COMPONENTS Interpreter Development)
   if(Python3_FOUND)
     set(boost_python_component "python${Python3_VERSION_MAJOR}${Python3_VERSION_MINOR}")
-  else()
-    # Backwards compatible. Can be removed once the Python3 recipe is stable
-    message(WARNING "Python 3 was not found: falling back to Python 3")
-    find_package(Python2 2.7 COMPONENTS Development REQUIRED)
-    set(boost_python_component "python27")
   endif()
 endif()
 
diff --git a/doc/releaseNotes.md b/doc/releaseNotes.md
@@ -66,3 +66,7 @@ This file describes the main feature changes for released versions of ReadoutCar
 - Fix registers for FEC status counters.
 - Updated list of firmwares for CRORC
 - CMake cleanup: removed python2 support.
+
+## v0.45.0 - 03/10/2023
+- o2-roc-pat-player: options have changed to match the [latest firmware conventions](https://gitlab.cern.ch/alice-cru/cru-fw/-/tree/pplayer/TTC#address-table). Values can specified as decimal or hexadecimal numbers.
+- Added support for pattern-player configuration parsing (used by ALF).
diff --git a/include/ReadoutCard/PatternPlayer.h b/include/ReadoutCard/PatternPlayer.h
@@ -33,43 +33,47 @@ class PatternPlayer
 {
  public:
   struct Info {
-    uint128_t syncPattern = 0x0;
-    uint128_t resetPattern = 0x0;
-    uint128_t idlePattern = 0x0;
-    uint32_t syncLength = 1;
-    uint32_t syncDelay = 0;
-    uint32_t resetLength = 1;
-    uint32_t resetTriggerSelect = 30;
-    uint32_t syncTriggerSelect = 29;
-    bool syncAtStart = false;
-    bool triggerSync = false;
-    bool triggerReset = false;
+    // as defined in https://gitlab.cern.ch/alice-cru/cru-fw/-/tree/pplayer/TTC#address-table
+    uint128_t pat0= 0x0;
+    uint128_t pat1 = 0x0;
+    uint128_t pat2 = 0x0;
+    uint128_t pat3 = 0x0;
+    uint32_t pat1Length = 1;
+    uint32_t pat1Delay = 0;
+    uint32_t pat2Length = 1;
+    uint32_t pat3Length = 1;
+    uint32_t pat1TriggerSelect = 29;
+    uint32_t pat2TriggerSelect = 30;
+    uint32_t pat3TriggerSelect = 0;
+    uint32_t pat2TriggerTF = 0;
+
+    bool exePat1AtStart = false;
+    bool exePat1Now = false;
+    bool exePat2Now = false;
   };
 
   PatternPlayer(std::shared_ptr<BarInterface> bar);
   void play(PatternPlayer::Info info);
   PatternPlayer::Info read();
 
+  // helper function to fill Info fields from string
+  // 128-bit string parser (both hex and decimal)
+  // nBits specifies the maximum allowed bit width
+  // name is used in the error message, if any
+  // throws exception on error
+  static uint128_t getValueFromString(const std::string &s, unsigned int nBits = 128, const std::string &name = "");
+
+  // parse a vector of strings into an Info struct
+  // strings with # are considered as comments and not used
+  // number of valid strings must match exactly number of parameters in struct
+  // throws an exception on error
+  static PatternPlayer::Info getInfoFromString(const std::vector<std::string> &parameters);
+
  private:
   void configure(bool startConfig);
-  void setIdlePattern(uint128_t pattern);
-  void setSyncPattern(uint128_t pattern);
-  void configureSync(uint32_t length = 1, uint32_t delay = 0);
-  void setResetPattern(uint128_t pattern);
-  void configureReset(uint32_t length = 1);
-  void selectPatternTrigger(uint32_t syncTrigger = 3, uint32_t resetTrigger = 3);
-  void enableSyncAtStart(bool enable = false);
-  void triggerSync();
-  void triggerReset();
-
-  uint128_t getSyncPattern();
-  uint128_t getResetPattern();
-  uint128_t getIdlePattern();
-  uint32_t getSyncLength();
-  uint32_t getSyncDelay();
-  uint32_t getResetLength();
-  uint32_t getResetTriggerSelect();
-  uint32_t getSyncTriggerSelect();
+  void exePat1AtStart(bool enable = false);
+  void exePat1();
+  void exePat2();
 
   std::shared_ptr<BarInterface> mBar;
 };
diff --git a/src/CommandLineUtilities/ProgramPatternPlayer.cxx b/src/CommandLineUtilities/ProgramPatternPlayer.cxx
@@ -1,4 +1,4 @@
-
+ 
 // Copyright 2019-2020 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
@@ -32,59 +32,51 @@ using namespace o2::roc;
 namespace po = boost::program_options;
 using namespace boost::multiprecision;
 
+
 class ProgramPatternPlayer : public Program
 {
  public:
   virtual Description getDescription()
   {
     return { "PatternPlayer", "Configure the CRU pattern player",
-             "o2-roc-pat-player --id 42:00.0 --sync 0x0123457899876543210abcdefedcb --sync-length 4 --sync-delay 2 --sync-at-start\n" };
+             "o2-roc-pat-player --id 42:00.0 --pat1 0x012345789abdef0123 --pat1-length 4 --pat1-delay 2 --execute-pat1-at-start\n" };
   }
 
   virtual void addOptions(boost::program_options::options_description& options)
   {
     Options::addOptionCardId(options);
-    options.add_options()("sync",
-                          po::value<std::string>(&mOptions.syncPattern)->default_value("0x0"),
-                          "80-bit sync pattern in hex");
-    options.add_options()("reset",
-                          po::value<std::string>(&mOptions.resetPattern)->default_value("0x0"),
-                          "80-bit reset pattern in hex");
-    options.add_options()("idle",
-                          po::value<std::string>(&mOptions.idlePattern)->default_value("0x0"),
-                          "80-bit idle pattern in hex");
-    options.add_options()("sync-length",
-                          po::value<uint32_t>(&mOptions.syncLength)->default_value(1),
-                          "Sync pattern's length");
-    options.add_options()("sync-delay",
-                          po::value<uint32_t>(&mOptions.syncDelay)->default_value(0),
-                          "Sync pattern's delay");
-    options.add_options()("reset-length",
-                          po::value<uint32_t>(&mOptions.resetLength)->default_value(1),
-                          "Reset pattern's length");
-    options.add_options()("reset-trigger-select",
-                          po::value<uint32_t>(&mOptions.resetTriggerSelect)->default_value(30),
-                          "Select trigger for SYNC from TTC_DATA[0-31]");
-    options.add_options()("sync-trigger-select",
-                          po::value<uint32_t>(&mOptions.syncTriggerSelect)->default_value(29),
-                          "Select trigger for RESET from TTC_DATA[0-31]");
-    options.add_options()("sync-at-start",
-                          po::bool_switch(&mOptions.syncAtStart)->default_value(false),
-                          "Enable automatically sending a sync pattern when runenable goes high");
-    options.add_options()("trigger-sync",
-                          po::bool_switch(&mOptions.triggerSync)->default_value(false),
-                          "Manually trigger the SYNC pattern");
-    options.add_options()("trigger-reset",
-                          po::bool_switch(&mOptions.triggerReset)->default_value(false),
-                          "Manually trigger the reset pattern");
+
+    optionValues.reserve(16); // need to keep same variable addresses
+
+    addOptionValue(options, "pat0", "80-bit pat0 pattern", &mOptions.info.pat0, 80);
+    addOptionValue(options, "pat1", "80-bit pat1 pattern", &mOptions.info.pat1, 80);
+    addOptionValue(options, "pat2", "80-bit pat2 pattern", &mOptions.info.pat2, 80);
+    addOptionValue(options, "pat3", "80-bit pat3 pattern", &mOptions.info.pat3, 80);
+    addOptionValue(options, "pat1-length", "pat1 pattern's length", &mOptions.info.pat1Length);
+    addOptionValue(options, "pat1-delay", "pat1 pattern's delay", &mOptions.info.pat1Delay);
+    addOptionValue(options, "pat2-length", "pat2 pattern's length", &mOptions.info.pat2Length);
+    addOptionValue(options, "pat2-trigger-counters", "Trigger counters for pat2: TF[31:20] ORBIT[19:12] BC[11:0]", &mOptions.info.pat2TriggerTF);
+    addOptionValue(options, "pat3-length", "pat3 pattern's length", &mOptions.info.pat3Length);
+    addOptionValue(options, "pat1-trigger-select", "Select trigger for pat1", &mOptions.info.pat1TriggerSelect);
+    addOptionValue(options, "pat2-trigger-select", "Select trigger for pat2", &mOptions.info.pat2TriggerSelect);
+    addOptionValue(options, "pat3-trigger-select", "Select trigger for pat3", &mOptions.info.pat3TriggerSelect);
+
+    options.add_options()("execute-pat1-at-start",
+                          po::bool_switch(&mOptions.info.exePat1AtStart)->default_value(false),
+                          "Enable automatically sending a pat1 pattern when runenable goes high");
+    options.add_options()("execute-pat1-now",
+                          po::bool_switch(&mOptions.info.exePat1Now)->default_value(false),
+                          "Manually trigger the pat1 pattern now");
+    options.add_options()("execute-pat2-now",
+                          po::bool_switch(&mOptions.info.exePat2Now)->default_value(false),
+                          "Manually trigger the pat2 pattern now");
     options.add_options()("read-back",
                           po::bool_switch(&mOptions.readBack)->default_value(false),
                           "Reads back the pattern player configuration [DOES NOT CONFIGURE!!]");
   }
 
   virtual void run(const boost::program_options::variables_map& map)
   {
-
     auto cardId = Options::getOptionCardId(map);
     auto params = Parameters::makeParameters(cardId, 2);
     auto bar2 = ChannelFactory().getBar(params);
@@ -98,47 +90,80 @@ class ProgramPatternPlayer : public Program
       return;
     }
 
+    // convert input strings to numbers
+    parseOptionValues();
+
     auto cruBar2 = std::dynamic_pointer_cast<CruBar>(bar2);
     if (!mOptions.readBack) {
-      cruBar2->patternPlayer({ uint128_t(mOptions.syncPattern), //TODO: Parse this correctly!
-                               uint128_t(mOptions.resetPattern),
-                               uint128_t(mOptions.idlePattern),
-                               mOptions.syncLength,
-                               mOptions.syncDelay,
-                               mOptions.resetLength,
-                               mOptions.resetTriggerSelect,
-                               mOptions.syncTriggerSelect,
-                               mOptions.syncAtStart,
-                               mOptions.triggerSync,
-                               mOptions.triggerReset });
+      cruBar2->patternPlayer(mOptions.info);
     } else {
       auto ppInfo = cruBar2->patternPlayerRead();
-      std::cout << "sync pattern:\t\t0x" << std::hex << ppInfo.syncPattern << std::endl;
-      std::cout << "reset pattern:\t\t0x" << ppInfo.resetPattern << std::endl;
-      std::cout << "idle pattern:\t\t0x" << ppInfo.idlePattern << std::dec << std::endl;
-      std::cout << "sync length:\t\t" << ppInfo.syncLength << std::endl;
-      std::cout << "sync delay:\t\t" << ppInfo.syncDelay << std::endl;
-      std::cout << "reset length:\t\t" << ppInfo.resetLength << std::endl;
-      std::cout << "reset trigger select:\t" << ppInfo.resetTriggerSelect << std::endl;
-      std::cout << "sync trigger select:\t" << ppInfo.syncTriggerSelect << std::endl;
+      std::cout << "pat0 pattern:\t\t0x" << std::hex << ppInfo.pat0 << std::endl;
+      std::cout << "pat1 pattern:\t\t0x" << std::hex << ppInfo.pat1 << std::endl;
+      std::cout << "pat2 pattern:\t\t0x" << std::hex << ppInfo.pat2 << std::endl;
+      std::cout << "pat3 pattern:\t\t0x" << std::hex << ppInfo.pat3 << std::endl;
+
+      std::cout << "pat1 length:\t\t" << std::dec << ppInfo.pat1Length << std::endl;
+      std::cout << "pat1 delay:\t\t" << std::dec << ppInfo.pat1Delay << std::endl;
+      std::cout << "pat2 length:\t\t" << std::dec << ppInfo.pat2Length << std::endl;
+      std::cout << "pat3 length:\t\t" << std::dec << ppInfo.pat3Length << std::endl;
+
+      std::cout << "pat1 trigger select:\t0x" << std::hex << ppInfo.pat1TriggerSelect << std::endl;
+      std::cout << "pat2 trigger select:\t0x" << std::hex << ppInfo.pat2TriggerSelect << std::endl;
+      std::cout << "pat3 trigger select:\t0x" << std::hex << ppInfo.pat3TriggerSelect << std::endl;
+
+      std::cout << "pat2 trigger counters:\t"
+        << "TF 0x" << std::hex << ((ppInfo.pat2TriggerTF >> 20) & 0xFFF)
+        << " ORBIT 0x" << std::hex << ((ppInfo.pat2TriggerTF >> 12) & 0xFF)
+        << " BC 0x" << std::hex << (ppInfo.pat2TriggerTF & 0xFFF)
+        << std::endl;
     }
   }
 
  private:
   struct OptionsStruct {
-    std::string syncPattern = "0x0";
-    std::string resetPattern = "0x0";
-    std::string idlePattern = "0x0";
-    uint32_t syncLength = 1;
-    uint32_t syncDelay = 0;
-    uint32_t resetLength = 1;
-    uint32_t resetTriggerSelect = 30;
-    uint32_t syncTriggerSelect = 29;
-    bool syncAtStart = false;
-    bool triggerSync = false;
-    bool triggerReset = false;
+    PatternPlayer::Info info;
     bool readBack = false;
   } mOptions;
+
+  struct OptionValue {
+    public:
+    enum OptionValueType {UINT32, UINT64, UINT128};
+    std::string name; // option name
+    std::string value; // string value
+    void * destination; // variable assigned when parsing value
+    unsigned int bitWidth; // maximum bit width allowed
+    OptionValueType type; // variable type
+  }; // namespace option
+
+  std::vector<OptionValue> optionValues;
+
+  // register 32bit option value
+  void addOptionValue(boost::program_options::options_description& options, const char *name, const char *description, uint32_t *destinationVariable, unsigned int bitWidth = 32) {
+    optionValues.push_back({name, "", destinationVariable, bitWidth, OptionValue::OptionValueType::UINT32});
+    options.add_options()(name, po::value<std::string>(&(optionValues.back().value)), description);
+  }
+
+  // register 128bit option value
+  void addOptionValue(boost::program_options::options_description& options, const char *name, const char *description, uint128_t *destinationVariable, unsigned int bitWidth = 128) {
+    optionValues.push_back({name, "", destinationVariable, bitWidth, OptionValue::OptionValueType::UINT128});
+    options.add_options()(name, po::value<std::string>(&(optionValues.back().value)), description);
+  }
+
+  // parse option values and assign corresponding variables
+  void parseOptionValues() {
+    for(const auto &opt : optionValues) {
+      if (opt.value.length()) {
+        uint128_t v;
+        v = PatternPlayer::getValueFromString(opt.value, opt.bitWidth, opt.name);
+        if (opt.type == OptionValue::OptionValueType::UINT32) {
+          *(static_cast<uint32_t *>(opt.destination)) = (uint32_t)v;
+        } else if (opt.type == OptionValue::OptionValueType::UINT128) {
+          *(static_cast<uint128_t *>(opt.destination)) = v;
+        }
+      }
+    }
+  }
 };
 
 int main(int argc, char** argv)
diff --git a/src/Cru/Constants.h b/src/Cru/Constants.h
@@ -354,20 +354,29 @@ static constexpr Register CTP_EMU_FBCT(0x00280024);
 static constexpr Register CTP_EMU_ORBIT_INIT(0x00280028);
 
 /// Registers for the Pattern Player
+/// see https://gitlab.cern.ch/alice-cru/cru-fw/-/tree/pplayer/TTC#address-table
 static constexpr Register PATPLAYER_CFG(0x00260000);
-static constexpr Register PATPLAYER_IDLE_PATTERN_0(0x00260004);
-static constexpr Register PATPLAYER_IDLE_PATTERN_1(0x00260008);
-static constexpr Register PATPLAYER_IDLE_PATTERN_2(0x0026000c);
-static constexpr Register PATPLAYER_SYNC_PATTERN_0(0x00260010);
-static constexpr Register PATPLAYER_SYNC_PATTERN_1(0x00260014);
-static constexpr Register PATPLAYER_SYNC_PATTERN_2(0x00260018);
-static constexpr Register PATPLAYER_RESET_PATTERN_0(0x0026001c);
-static constexpr Register PATPLAYER_RESET_PATTERN_1(0x00260020);
-static constexpr Register PATPLAYER_RESET_PATTERN_2(0x00260024);
-static constexpr Register PATPLAYER_SYNC_CNT(0x00260028);
-static constexpr Register PATPLAYER_DELAY_CNT(0x0026002c);
-static constexpr Register PATPLAYER_RESET_CNT(0x00260030);
-static constexpr Register PATPLAYER_TRIGGER_SEL(0x00260034);
+static constexpr Register PATPLAYER_PAT0_0(0x00260004);
+static constexpr Register PATPLAYER_PAT0_1(0x00260008);
+static constexpr Register PATPLAYER_PAT0_2(0x0026000c);
+static constexpr Register PATPLAYER_PAT1_0(0x00260010);
+static constexpr Register PATPLAYER_PAT1_1(0x00260014);
+static constexpr Register PATPLAYER_PAT1_2(0x00260018);
+static constexpr Register PATPLAYER_PAT2_0(0x0026001c);
+static constexpr Register PATPLAYER_PAT2_1(0x00260020);
+static constexpr Register PATPLAYER_PAT2_2(0x00260024);
+static constexpr Register PATPLAYER_PAT1_LENGTH(0x00260028);
+static constexpr Register PATPLAYER_PAT1_DELAY_CNT(0x0026002c);
+static constexpr Register PATPLAYER_PAT2_LENGTH(0x00260030);
+static constexpr Register PATPLAYER_PAT1_TRIGGER_SEL(0x00260034);
+static constexpr Register PATPLAYER_PAT2_TRIGGER_SEL(0x00260038);
+static constexpr Register PATPLAYER_PAT3_TRIGGER_SEL(0x0026003c);
+static constexpr Register PATPLAYER_PAT2_TRIGGER_TF(0x00260040);
+static constexpr Register PATPLAYER_PAT3_LENGTH(0x00260044);
+static constexpr Register PATPLAYER_PAT3_0(0x00260048);
+static constexpr Register PATPLAYER_PAT3_1(0x0026004c);
+static constexpr Register PATPLAYER_PAT3_2(0x00260050);
+
 
 //** I2C **//
 /// I2C base addresses
diff --git a/src/Cru/PatternPlayer.cxx b/src/Cru/PatternPlayer.cxx
diff --git a/src/ReadoutCardVersion.cxx b/src/ReadoutCardVersion.cxx
