MasterDesign.cpp

Go to the documentation of this file.

#include "timing/MasterDesign.hpp"
 
#include <sstream>
#include <string>
 
namespace dunedaq::timing {
 
UHAL_REGISTER_DERIVED_NODE(MasterDesign)
 
//-----------------------------------------------------------------------------
MasterDesign::MasterDesign(const uhal::Node& node)
  : TopDesignInterface(node)
  , MasterDesignInterface(node)
  , TopDesign(node)
{}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
MasterDesign::~MasterDesign()
{}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::string
MasterDesign::get_status(bool print_out) const
{
  std::stringstream status;
  status << this->get_io_node_plain()->get_pll_status();
  status << get_master_node_plain()->get_status();
 
  if (print_out)
    TLOG() << status.str();
  return status.str();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::configure(ClockSource clock_source, TimestampSource ts_source) const
{
  // Hard resets
  TopDesign::configure(clock_source);
 
  this->sync_timestamp(ts_source); // keep previous behaviour for now, TODO: pass through correct parameter
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint64_t
MasterDesign::read_master_timestamp() const
{
  return get_master_node_plain()->read_timestamp();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::sync_timestamp(TimestampSource source) const
{
  get_master_node_plain()->sync_timestamp(source);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint32_t
MasterDesign::measure_endpoint_rtt(uint32_t address, bool control_sfp, int /*sfp_mux*/) const
{
  return get_master_node_plain()->measure_endpoint_rtt(address, control_sfp);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::apply_endpoint_delay(uint32_t address,
                                            uint32_t coarse_delay,
                                            uint32_t fine_delay,
                                            uint32_t phase_delay,
                                            bool measure_rtt,
                                            bool control_sfp,
                                            int /*sfp_mux*/) const
{
  get_master_node_plain()->apply_endpoint_delay(address, coarse_delay, fine_delay, phase_delay, measure_rtt, control_sfp);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::enable_periodic_fl_cmd(uint32_t channel, double rate, bool poisson) const // NOLINT(build/unsigned)
{
  auto dts_clock_frequency = this->get_io_node_plain()->read_firmware_frequency();
  get_master_node_plain()->enable_periodic_fl_cmd(channel, rate, poisson, dts_clock_frequency);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::enable_periodic_fl_cmd(uint32_t command, uint32_t channel, double rate, bool poisson) const // NOLINT(build/unsigned)
{
  auto dts_clock_frequency = this->get_io_node_plain()->read_firmware_frequency();
  get_master_node_plain()->enable_periodic_fl_cmd(command, channel, rate, poisson, dts_clock_frequency);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint32_t
MasterDesign::read_firmware_version() const // NOLINT(build/unsigned)
{
  auto firmware_version = this->get_master_node_plain()->getNode("global.version").read();
  uhal::Node::getClient().dispatch();
 
  return firmware_version.value();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::validate_firmware_version() const
{
  auto firmware_version = read_firmware_version();
 
  uint32_t major_firmware_version = (firmware_version >> 16) & 0xff;
  uint32_t minor_firmware_version = (firmware_version >> 8) & 0xff;
  uint32_t patch_firmware_version = (firmware_version >> 0) & 0xff;
 
  if (major_firmware_version != get_master_node_plain()->get_required_major_firmware_version())
    ers::error(IncompatibleMajorMasterFirmwareVersion(ERS_HERE, major_firmware_version, get_master_node_plain()->get_required_major_firmware_version()));
  if (minor_firmware_version != get_master_node_plain()->get_required_minor_firmware_version())
    ers::warning(IncompatibleMinorMasterFirmwareVersion(ERS_HERE, minor_firmware_version, get_master_node_plain()->get_required_minor_firmware_version()));
  if (patch_firmware_version != get_master_node_plain()->get_required_patch_firmware_version())
    ers::warning(IncompatiblePatchMasterFirmwareVersion(ERS_HERE, patch_firmware_version, get_master_node_plain()->get_required_patch_firmware_version()));
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
MasterDesign::get_info(timingfirmwareinfo::TimingDeviceInfo& mon_data) const
{
  TopDesign::get_info(mon_data);
  get_info(mon_data.master_info);
}
//-----------------------------------------------------------------------------
}