MasterNode.hpp

Go to the documentation of this file.

 
#ifndef TIMING_INCLUDE_TIMING_MASTERNODE_HPP_
#define TIMING_INCLUDE_TIMING_MASTERNODE_HPP_
 
// PDT Headers
#include "timing/definitions.hpp"
#include "timing/toolbox.hpp"
#include "timing/FLCmdGeneratorNode.hpp"
#include "timing/MasterNodeInterface.hpp"
#include "timing/MasterGlobalNode.hpp"
 
#include "timing/timingfirmware/Nljs.hpp"
#include "timing/timingfirmware/Structs.hpp"
 
// uHal Headers
#include "uhal/DerivedNode.hpp"
 
// C++ Headers
#include <chrono>
#include <string>
 
namespace dunedaq {
namespace timing {
 
class MasterNode : public MasterNodeInterface
{
  UHAL_DERIVEDNODE(MasterNode)
public:
  explicit MasterNode(const uhal::Node& node);
  virtual ~MasterNode();
 
  std::string get_status(bool print_out = false) const override;
 
  std::string get_status_with_date(uint32_t clock_frequency_hz, bool print_out = false) const; // NOLINT(build/unsigned)
 
  void switch_endpoint_sfp(uint32_t address, bool turn_on) const override; // NOLINT(build/unsigned)
 
  void enable_upstream_endpoint() const override;
 
  void send_fl_cmd(uint32_t command,                                // NOLINT(build/unsigned)
                   uint32_t channel,                                // NOLINT(build/unsigned)
                   uint32_t number_of_commands = 1) const override; // NOLINT(build/unsigned)
  
  uint32_t measure_endpoint_rtt(uint32_t address, bool control_sfp = true) const override; // NOLINT(build/unsigned)
 
  void apply_endpoint_delay(uint32_t address,      // NOLINT(build/unsigned)
                            uint32_t coarse_delay, // NOLINT(build/unsigned)
                            uint32_t fine_delay,   // NOLINT(build/unsigned)
                            uint32_t phase_delay,  // NOLINT(build/unsigned)
                            bool measure_rtt = false,
                            bool control_sfp = true) const override;
 
  using MasterNodeInterface::apply_endpoint_delay;
 
  void sync_timestamp(TimestampSource source) const override; // NOLINT(build/unsigned)
 
  uint64_t read_timestamp() const override; // NOLINT(build/unsigned)
 
  void set_timestamp(TimestampSource source) const override; // NOLINT(build/unsigned)
 
  void get_info(timingfirmwareinfo::MasterMonitorData& mon_data) const;
 
  void reset_command_counters() const;
 
  std::vector<uint32_t> transmit_async_packet(const std::vector<uint32_t>& packet, int timeout=500) const;
 
  void write_endpoint_data(uint16_t endpoint_address, uint8_t reg_address, std::vector<uint8_t> data, bool address_mode) const;
 
  std::vector<uint32_t> read_endpoint_data(uint16_t endpoint_address, uint8_t reg_address, uint8_t data_length, bool address_mode) const;
 
  void disable_timestamp_broadcast() const;
 
  void enable_timestamp_broadcast() const;
 
  timingfirmware::EndpointCheckResult scan_endpoint(uint16_t endpoint_address, bool control_sfp) const override;
 
  void configure_endpoint_command_decoder(uint16_t endpoint_address, uint8_t slot, uint8_t command) const;
 
  uint32_t get_required_major_firmware_version() const override { return required_major_firmware_version; }
 
  uint32_t get_required_minor_firmware_version() const override { return required_minor_firmware_version; }
 
  uint32_t get_required_patch_firmware_version() const override { return required_patch_firmware_version; }
 
  const static uint32_t required_major_firmware_version = 7;
  const static uint32_t required_minor_firmware_version = 5;
  const static uint32_t required_patch_firmware_version = 0;
private:
  std::string get_status_tables() const;
};
 
} // namespace timing
} // namespace dunedaq
 
#endif // TIMING_INCLUDE_TIMING_PDIMASTERNODE_HPP_