dunedaq::timing::EndpointNode Class Reference

Base class for timing IO nodes. More...

#include <EndpointNode.hpp>

Inheritance diagram for dunedaq::timing::EndpointNode:

Collaboration diagram for dunedaq::timing::EndpointNode:

Public Member Functions
	EndpointNode (const uhal::Node &node)
virtual	~EndpointNode ()
std::string	get_status (bool print_out=false) const override
	Print the status of the timing node.
void	enable (uint32_t address=0, uint32_t partition=0) const override
	Enable the endpoint.
void	disable () const override
	Disable the endpoint.
void	reset (uint32_t address=0, uint32_t partition=0) const override
	Reset the endpoint.
virtual uint64_t	read_timestamp () const
	Read the current timestamp word.
void	get_info (timingendpointinfo::TimingEndpointInfo &mon_data) const override
	Read the endpoint clock frequency.
Public Member Functions inherited from dunedaq::timing::EndpointNodeInterface
	EndpointNodeInterface (const uhal::Node &node)
virtual	~EndpointNodeInterface ()
virtual bool	endpoint_ready () const
	Get endpoint ready flag.
virtual uint32_t	read_endpoint_state () const
	Get endpoint state.
Public Member Functions inherited from dunedaq::timing::TimingNode
	TimingNode (const uhal::Node &node)
virtual	~TimingNode ()
std::map< std::string, uhal::ValWord< uint32_t > >	read_sub_nodes (const uhal::Node &node, bool dispatch=true) const
	Read subnodes.
void	reset_sub_nodes (const uhal::Node &node, uint32_t aValue=0x0, bool dispatch=true) const
	Reset subnodes.

Static Public Member Functions
static std::map< uint8_t, std::string >	get_endpoint_state_map ()
	Get the states map.

Static Protected Attributes
static const std::map< uint8_t, std::string >	endpoint_state_map

Detailed Description

Base class for timing IO nodes.

Definition at line 35 of file EndpointNode.hpp.

Constructor & Destructor Documentation

EndpointNode()

dunedaq::timing::EndpointNode::EndpointNode ( const uhal::Node & node )

explicit

Definition at line 24 of file EndpointNode.cpp.

  : EndpointNodeInterface(node)
{}

~EndpointNode()

dunedaq::timing::EndpointNode::~EndpointNode ( )

virtual

Definition at line 30 of file EndpointNode.cpp.

{}

Member Function Documentation

disable()

void dunedaq::timing::EndpointNode::disable ( ) const

overridevirtual

Disable the endpoint.

Returns

{ description_of_the_return_value }

Implements dunedaq::timing::EndpointNodeInterface.

Definition at line 73 of file EndpointNode.cpp.

{
  getNode("csr.ctrl.ep_en").write(0x0);
//  getNode("csr.ctrl.buf_en").write(0x0);
  getClient().dispatch();
}

enable()

void dunedaq::timing::EndpointNode::enable ( uint32_t address = 0, uint32_t partition = 0 ) const

overridevirtual

Enable the endpoint.

Returns

{ description_of_the_return_value }

Implements dunedaq::timing::EndpointNodeInterface.

Definition at line 35 of file EndpointNode.cpp.

{
  getNode("csr.ctrl.addr").write(address);
 
  getNode("csr.ctrl.ep_en").write(0x1);
  getClient().dispatch();
 
  auto start = std::chrono::high_resolution_clock::now();
 
  std::chrono::milliseconds ms_since_start(0);
 
  uhal::ValWord<uint32_t> counters_ready;
 
  // Wait for the endpoint to be happy
  while (ms_since_start.count() < 500) {
    auto now = std::chrono::high_resolution_clock::now();
    ms_since_start = std::chrono::duration_cast<std::chrono::milliseconds>(now - start);
 
    millisleep(10);
 
    counters_ready = getNode("csr.stat.ctrs_rdy").read();
    getClient().dispatch();
    TLOG_DEBUG(1) << "counters_ready: 0x" << std::hex << counters_ready.value();
 
    if (counters_ready) {
      TLOG_DEBUG(1) << "counters ready";
      break;
    }
  }
 
  if (!counters_ready) {
    ers::warning(EndpointBroadcastMessageCountersNotReady(ERS_HERE));
  }
}

get_endpoint_state_map()

static std::map< uint8_t, std::string > dunedaq::timing::EndpointNode::get_endpoint_state_map ( )

inlinestatic

Get the states map.

Definition at line 91 of file EndpointNode.hpp.

{ return endpoint_state_map; }

get_info()

void dunedaq::timing::EndpointNode::get_info ( timingendpointinfo::TimingEndpointInfo & mon_data ) const

overridevirtual

Read the endpoint clock frequency.

Returns

{ description_of_the_return_value }

Collect monitoring information for timing endpoint

Reimplemented from dunedaq::timing::EndpointNodeInterface.

Definition at line 158 of file EndpointNode.cpp.

{
  auto timestamp = getNode("tstamp").readBlock(2);
  auto endpoint_control = read_sub_nodes(getNode("csr.ctrl"), false);
  auto endpoint_state = read_sub_nodes(getNode("csr.stat"), false);
  getClient().dispatch();
 
  mon_data.state = endpoint_state.at("ep_stat").value();
  mon_data.ready = endpoint_state.at("ep_rdy").value();
  mon_data.address = endpoint_control.at("addr").value();
  mon_data.timestamp = tstamp2int(timestamp);
  mon_data.sfp_tx_disable = !endpoint_state.at("ep_txen").value();
}

get_status()

std::string dunedaq::timing::EndpointNode::get_status ( bool print_out = false ) const

overridevirtual

Print the status of the timing node.

Implements dunedaq::timing::TimingNode.

Definition at line 99 of file EndpointNode.cpp.

{
 
  std::stringstream status;
 
  std::vector<std::pair<std::string, std::string>> ept_summary;
 
  auto ept_timestamp = getNode("tstamp").readBlock(2);
  auto ept_control = read_sub_nodes(getNode("csr.ctrl"), false);
  auto ept_state = read_sub_nodes(getNode("csr.stat"), false);
  getNode("cmd_ctrs.addr").write(0x0);
  auto counters = getNode("cmd_ctrs.data").readBlock(0xff);
  getClient().dispatch();
 
  ept_summary.push_back(std::make_pair("Enabled", std::to_string(ept_control.find("ep_en")->second.value())));
  ept_summary.push_back(std::make_pair("Address", std::to_string(ept_control.find("addr")->second.value())));
  ept_summary.push_back(std::make_pair("State", get_endpoint_state_map().at(ept_state.find("ep_stat")->second.value())));
  ept_summary.push_back(std::make_pair("Timestamp (hex)", format_reg_value(tstamp2int(ept_timestamp))));
  ept_summary.push_back(std::make_pair("Timestamp", format_timestamp(ept_timestamp,62500000)));
 
  status << std::endl << format_reg_table(ept_summary, "Endpoint summary", { "", "" }) << std::endl;
//  status << "Endpoint frequency: " << ept_clock_frequency << " MHz" << std::endl;
  status << format_reg_table(ept_state, "Endpoint state") << std::endl;
  
  std::vector<uint32_t> non_zero_counters;
  std::vector<std::string> counter_labels;
 
  for (uint i=0; i < counters.size(); ++i) 
  {
    auto counter = counters.at(i);
    if (counter > 0)
    {
      counter_labels.push_back(format_reg_value(i));
      non_zero_counters.push_back(counter);
    }
  }
  std::vector<std::vector<uint32_t>> counters_container = { non_zero_counters }; // NOLINT(build/unsigned)
 
  status << format_counters_table(counters_container, { "Received cmd counters" }, "Endpoint cmd counters (>0)", counter_labels);
  status << std::endl;
 
  if (print_out)
    TLOG() << status.str();
  return status.str();
}

read_timestamp()

uint64_t dunedaq::timing::EndpointNode::read_timestamp ( ) const

virtual

Read the current timestamp word.

Returns

{ description_of_the_return_value }

Definition at line 148 of file EndpointNode.cpp.

{
  auto timestamp = getNode("tstamp").readBlock(2);
  getClient().dispatch();
  return tstamp2int(timestamp);
}

reset()

void dunedaq::timing::EndpointNode::reset ( uint32_t address = 0, uint32_t partition = 0 ) const

overridevirtual

Reset the endpoint.

Returns

{ description_of_the_return_value }

Implements dunedaq::timing::EndpointNodeInterface.

Definition at line 83 of file EndpointNode.cpp.

{
 
  getNode("csr.ctrl.ep_en").write(0x0);
  getNode("csr.ctrl.ctr_rst").write(0x1);
  getNode("csr.ctrl.ctr_rst").write(0x0);
  getClient().dispatch();
 
  //getNode("csr.ctrl.buf_en").write(0x0);
 
  enable(address);
}

Member Data Documentation

endpoint_state_map

const std::map<uint8_t, std::string> dunedaq::timing::EndpointNode::endpoint_state_map

inlinestaticprotected

Initial value:

{
    { 0x0, "Standing by (0x0)" },                          
    { 0x1, "Waiting for input clock (0x1)" },              
    { 0x2, "Waiting for good frequency check (0x2)" },     
    { 0x3, "Waiting for internal CDR to lock (0x3)" },     
    { 0x4, "Waiting for rx block to lock (0x4)" },         
    { 0x5, "Waiting for address to be set (0x5)" },        
    { 0x6, "Waiting for deskew to be set (0x6)" },         
    { 0x7, "Waiting for timestamp initialisation (0x7)" }, 
    { 0x8, "Ready (0x8)" },                                
    { 0xc, "Error in physical layer (0xc)" },              
    { 0xd, "Receive error (0xd)" },                        
    { 0xe, "Time check error (0xe)" },                     
    { 0xf, "Protocol error (0xf)" },                       
  }

Definition at line 94 of file EndpointNode.hpp.

  {
    { 0x0, "Standing by (0x0)" },                          // 0b0000 when ST_RESET, -- Endpoint in in reset
    { 0x1, "Waiting for input clock (0x1)" },              // 0b0001 when ST_W_CLK, -- Waiting for input clock
    { 0x2, "Waiting for good frequency check (0x2)" },     // 0b0010 when ST_W_FREQ, -- Waiting for frequency check
    { 0x3, "Waiting for internal CDR to lock (0x3)" },     // 0b0011 when ST_W_CDR, -- Waiting for internal CDR to lock
    { 0x4, "Waiting for rx block to lock (0x4)" },         // 0b0100 when ST_W_RX, -- Waiting for rx block to lock
    { 0x5, "Waiting for address to be set (0x5)" },        // 0b0101 when ST_W_ADDR, -- Waiting for address to be set
    { 0x6, "Waiting for deskew to be set (0x6)" },         // 0b0110 when ST_W_DESKEW, -- Waiting for deskew to be set
    { 0x7, "Waiting for timestamp initialisation (0x7)" }, // 0b0111 when ST_W_TS, -- Waiting for timestamp initialisation
    { 0x8, "Ready (0x8)" },                                // 0b1000 when ST_READY, -- Good to go
    { 0xc, "Error in physical layer (0xc)" },              // 0b1100 when ST_ERR_P, -- Error in physical layer
    { 0xd, "Receive error (0xd)" },                        // 0b1101 when ST_ERR_R, -- Receive error
    { 0xe, "Time check error (0xe)" },                     // 0b1110 when ST_ERR_T, -- Time check error
    { 0xf, "Protocol error (0xf)" },                       // 0b1111 when ST_ERR_X; -- Protocol error
  };

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/timing/include/timing/EndpointNode.hpp
• /github/workspace/dunedaq/sourcecode/timing/src/EndpointNode.cpp