dunedaq::hermesmodules::HermesCoreController Class Reference

#include <HermesCoreController.hpp>

Collaboration diagram for dunedaq::hermesmodules::HermesCoreController:

Classes
struct	CoreInfo
struct	LinkGeoInfo

Public Member Functions
	HermesCoreController (uhal::HwInterface, std::string readout_id="")
virtual	~HermesCoreController ()
const CoreInfo &	get_info () const
void	sel_tx_mux (uint16_t i)
void	sel_tx_mux_buf (uint16_t i)
void	sel_udp_core (uint16_t i)
void	reset (bool nuke=false)
bool	is_link_in_error (uint16_t link, bool do_throw=false)
void	enable (uint16_t link, bool enable)
void	config_mux (uint16_t link, uint16_t det, uint16_t crate, uint16_t slot)
void	config_udp (uint16_t link, uint64_t src_mac, uint32_t src_ip, uint16_t src_port, uint64_t dst_mac, uint32_t dst_ip, uint16_t dst_port, uint32_t filters)
void	config_fake_src (uint16_t link, uint16_t n_src, uint16_t data_len, uint16_t rate)
LinkGeoInfo	read_link_geo_info (uint16_t link)
opmon::LinkInfo	read_link_stats (uint16_t link)

Private Member Functions
void	load_hw_info ()

Private Attributes
uhal::HwInterface	m_hw
const uhal::Node &	m_readout
CoreInfo	m_core_info

Detailed Description

Definition at line 46 of file HermesCoreController.hpp.

Constructor & Destructor Documentation

HermesCoreController()

dunedaq::hermesmodules::HermesCoreController::HermesCoreController ( uhal::HwInterface hw, std::string readout_id = "" )

explicit

Definition at line 11 of file HermesCoreController.cpp.

                                                                                   :
  m_hw(hw), m_readout(m_hw.getNode(readout_id)) {
 
    this->load_hw_info();
 
}

~HermesCoreController()

dunedaq::hermesmodules::HermesCoreController::~HermesCoreController ( )

virtual

Definition at line 19 of file HermesCoreController.cpp.

                                            {
 
}

Member Function Documentation

config_fake_src()

void dunedaq::hermesmodules::HermesCoreController::config_fake_src	(	uint16_t	link,
		uint16_t	n_src,
		uint16_t	data_len,
		uint16_t	rate )

Definition at line 273 of file HermesCoreController.cpp.

                                                                                                     {
 
  this->sel_tx_mux(link);
 
  auto was_en_buf = m_readout.getNode("tx_path.tx_mux.csr.ctrl.en_buf").read();
  m_readout.getNode("tx_path.tx_mux.csr.ctrl.en_buf").write(0x0);
  m_readout.getClient().dispatch();
 
 
 
  for ( size_t src_id(0); src_id<m_core_info.srcs_per_mux; ++src_id) {
    this->sel_tx_mux_buf(src_id);
 
 
    bool src_en = (src_id<n_src);
    m_readout.getNode("tx_path.tx_mux.buf.ctrl.fake_en").write(src_en);
    m_readout.getClient().dispatch();
    if (!src_en) {
      continue;
    }
    m_readout.getNode("tx_path.tx_mux.buf.ctrl.dlen").write(data_len);
        
    m_readout.getNode("tx_path.tx_mux.buf.ctrl.rate_rdx").write(rate);
    m_readout.getClient().dispatch();
  }
 
  m_readout.getNode("tx_path.tx_mux.csr.ctrl.en_buf").write(was_en_buf.value());
  m_readout.getClient().dispatch();
}

config_mux()

void dunedaq::hermesmodules::HermesCoreController::config_mux	(	uint16_t	link,
		uint16_t	det,
		uint16_t	crate,
		uint16_t	slot )

Definition at line 217 of file HermesCoreController.cpp.

                                                                                           {
  this->sel_tx_mux(link);
 
 
  auto& mux_ctrl = m_readout.getNode("tx_path.tx_mux.mux.ctrl");
 
  mux_ctrl.getNode("detid").write(det);
  mux_ctrl.getNode("crate").write(crate);
  mux_ctrl.getNode("slot").write(slot);
  mux_ctrl.getClient().dispatch();
    
}

config_udp()

void dunedaq::hermesmodules::HermesCoreController::config_udp	(	uint16_t	link,
		uint64_t	src_mac,
		uint32_t	src_ip,
		uint16_t	src_port,
		uint64_t	dst_mac,
		uint32_t	dst_ip,
		uint16_t	dst_port,
		uint32_t	filters )

Definition at line 233 of file HermesCoreController.cpp.

                                                                                                                                                                             {
 
  if ( link >= m_core_info.n_mgt ) {
    throw LinkDoesNotExist(ERS_HERE, link);
  }
 
  this->sel_udp_core(link);
 
  // const std::string udp_ctrl_name = fmt::format("udp.udp_core_{}.udp_core_control.nz_rst_ctrl");
  const auto& udp_ctrl = m_readout.getNode("tx_path.udp_core.udp_core_control");
 
 
  udp_ctrl.getNode("src_addr_ctrl.use_external").write(0);  
 
  // Load the source mac address
  udp_ctrl.getNode("src_addr_ctrl.src_mac_addr_lower").write(src_mac & 0xffffffff);
  udp_ctrl.getNode("src_addr_ctrl.src_mac_addr_upper").write((src_mac >> 32) & 0xffff);
 
  // Load the source ip address
  udp_ctrl.getNode("src_addr_ctrl.src_ip_addr").write(src_ip);
 
  // Load the dst mac address
  udp_ctrl.getNode("ctrl.dst_mac_addr_lower").write(dst_mac & 0xffffffff);
  udp_ctrl.getNode("ctrl.dst_mac_addr_upper").write((dst_mac >> 32) & 0xffff);
 
  // Load the dst ip address
  udp_ctrl.getNode("ctrl.dst_ip_addr").write(dst_ip);
 
  // Ports
  udp_ctrl.getNode("src_addr_ctrl.src_port").write(src_port);
  udp_ctrl.getNode("ctrl.dst_port").write(dst_port);
 
 
  udp_ctrl.getNode("ctrl.filter_control").write(filters);
  udp_ctrl.getClient().dispatch();
 
}

enable()

void dunedaq::hermesmodules::HermesCoreController::enable	(	uint16_t	link,
		bool	enable )

Definition at line 168 of file HermesCoreController.cpp.

                                                       {
 
  this->sel_tx_mux(link);
 
  auto& tx_mux_ctrl = m_readout.getNode("tx_path.tx_mux.csr.ctrl");
  
  // Not sure what to do with this
  auto tx_en = tx_mux_ctrl.getNode("tx_en").read();
  auto buf_en = tx_mux_ctrl.getNode("en_buf").read();
  auto ctrl_en = tx_mux_ctrl.getNode("en").read();
 
  if ( enable ) {
 
    // Assume that all is off
 
    // Enable the main logic
    tx_mux_ctrl.getNode("en").write(0x1);
    tx_mux_ctrl.getClient().dispatch();
 
    // Enable transmitter first
    tx_mux_ctrl.getNode("tx_en").write(0x1);
    tx_mux_ctrl.getClient().dispatch();
 
    // Enable buffers last
    tx_mux_ctrl.getNode("en_buf").write(0x1);
    tx_mux_ctrl.getClient().dispatch();
 
 
  } else {
 
    // Disable buffers last
    tx_mux_ctrl.getNode("en_buf").write(0x0);
    tx_mux_ctrl.getClient().dispatch();
 
    // Disable transmitter first
    tx_mux_ctrl.getNode("tx_en").write(0x0);
    tx_mux_ctrl.getClient().dispatch();
 
    // Disable the main logic
    tx_mux_ctrl.getNode("en").write(0x0);
    tx_mux_ctrl.getClient().dispatch();
 
  }
 
}

get_info()

const CoreInfo & dunedaq::hermesmodules::HermesCoreController::get_info ( ) const

inline

Definition at line 70 of file HermesCoreController.hpp.

{ return m_core_info; }

is_link_in_error()

bool dunedaq::hermesmodules::HermesCoreController::is_link_in_error	(	uint16_t	link,
		bool	do_throw = false )

Definition at line 146 of file HermesCoreController.cpp.

                                                                   {
 
  this->sel_tx_mux(link);
 
  auto& tx_mux_stat = m_readout.getNode("tx_path.tx_mux.csr.stat");
  auto err = tx_mux_stat.getNode("err").read();
  auto eth_rdy = tx_mux_stat.getNode("eth_rdy").read();
  auto src_rdy = tx_mux_stat.getNode("src_rdy").read();
  auto udp_rdy = tx_mux_stat.getNode("udp_rdy").read();
  tx_mux_stat.getClient().dispatch();
 
  bool is_error = (err || !eth_rdy || !src_rdy || !udp_rdy);
 
  if ( do_throw && is_error ) {
    throw LinkInError(ERS_HERE, link, err, eth_rdy, src_rdy, udp_rdy);
  }
 
  return is_error;
}

load_hw_info()

void dunedaq::hermesmodules::HermesCoreController::load_hw_info ( )

private

Definition at line 25 of file HermesCoreController.cpp.

                                   {
 
  // Check magic number
  auto magic = m_readout.getNode("info.magic").read();
  m_readout.getClient().dispatch();
  if (magic.value() != 0xdeadbeef){
      // TODO: add ERS exception
      throw MagicNumberError(ERS_HERE, magic.value(),0xdeadbeef);
  }
 
 
  auto design = m_readout.getNode("info.versions.design").read();
  auto major = m_readout.getNode("info.versions.major").read();
  auto minor = m_readout.getNode("info.versions.minor").read();
  auto patch = m_readout.getNode("info.versions.patch").read();
 
 
  auto n_mgt = m_readout.getNode("info.generics.n_mgts").read();
  auto n_src = m_readout.getNode("info.generics.n_srcs").read();
  auto ref_freq = m_readout.getNode("info.generics.ref_freq").read();
  m_readout.getClient().dispatch();
 
  // Version
  m_core_info.design = design.value();
  m_core_info.major = major.value();
  m_core_info.minor = minor.value();
  m_core_info.patch = patch.value();
 
  // Generics
  m_core_info.n_mgt = n_mgt.value();
  m_core_info.n_src = n_src.value();
  m_core_info.ref_freq = ref_freq.value();
 
  // Extra info
  m_core_info.srcs_per_mux = m_core_info.n_src;
 
  fmt::print("Number of links: {}\n", m_core_info.n_mgt);
  fmt::print("Number of sources: {}\n", m_core_info.n_src);
  fmt::print("Reference freq: {}\n", m_core_info.ref_freq);
  fmt::print("Sources per mux:{}\n",  m_core_info.srcs_per_mux);
 
}

read_link_geo_info()

HermesCoreController::LinkGeoInfo dunedaq::hermesmodules::HermesCoreController::read_link_geo_info

(

uint16_t

link

)

Definition at line 306 of file HermesCoreController.cpp.

                                                      {
 
  this->sel_tx_mux(link);
 
  auto detid = m_readout.getNode("tx_path.tx_mux.mux.ctrl.detid").read();
  auto crate = m_readout.getNode("tx_path.tx_mux.mux.ctrl.crate").read();
  auto slot = m_readout.getNode("tx_path.tx_mux.mux.ctrl.slot").read();
 
  m_readout.getClient().dispatch();
 
  return {detid.value(), crate.value(), slot.value()};
}

read_link_stats()

opmon::LinkInfo dunedaq::hermesmodules::HermesCoreController::read_link_stats

(

uint16_t

link

)

Definition at line 321 of file HermesCoreController.cpp.

                                                     {
    this->sel_tx_mux(link);
    this->sel_udp_core(link);
 
    opmon::LinkInfo info;
 
    const auto& mux_stats = m_readout.getNode("tx_path.tx_mux.csr.stat");
    auto err = mux_stats.getNode("err").read();
    auto eth_rdy = mux_stats.getNode("eth_rdy").read();
    auto src_rdy = mux_stats.getNode("src_rdy").read();
    auto udp_rdy = mux_stats.getNode("udp_rdy").read();
    mux_stats.getClient().dispatch();
 
    const auto& udp_ctrl = m_readout.getNode(fmt::format("tx_path.udp_core.udp_core_control"));
    const auto& rx_stats = udp_ctrl.getNode("rx_packet_counters");
 
    auto rx_arp_count = rx_stats.getNode("arp_count").read();
    auto rx_ping_count = rx_stats.getNode("ping_count").read();
    auto rx_udp_count = rx_stats.getNode("udp_count").read();
    rx_stats.getClient().dispatch();
 
    const auto& tx_stats = udp_ctrl.getNode("tx_packet_counters");
 
    auto tx_arp_count = tx_stats.getNode("arp_count").read();
    auto tx_ping_count = tx_stats.getNode("ping_count").read();
    auto tx_udp_count = tx_stats.getNode("udp_count").read();
    tx_stats.getClient().dispatch();
 
 
    info.set_err(err.value());
    info.set_eth_rdy(eth_rdy.value());
    info.set_src_rdy(src_rdy.value());
    info.set_udp_rdy(udp_rdy.value());
 
    info.set_rcvd_arp_count(rx_arp_count.value());
    info.set_rcvd_ping_count(rx_ping_count.value());
    info.set_rcvd_udp_count(rx_udp_count.value());
 
    info.set_sent_arp_count(tx_arp_count.value());
    info.set_sent_ping_count(tx_ping_count.value());
    info.set_sent_udp_count(tx_udp_count.value());
 
    return info;
 
  }

reset()

void dunedaq::hermesmodules::HermesCoreController::reset

(

bool

nuke = false

)

Definition at line 107 of file HermesCoreController.cpp.

                                     {
 
    if (nuke) {
        m_readout.getNode("csr.ctrl.nuke").write(0x1);
        m_readout.getClient().dispatch();
 
        // time.sleep(0.1);
        std::this_thread::sleep_for (std::chrono::milliseconds(1));
 
        m_readout.getNode("csr.ctrl.nuke").write(0x0);
        m_readout.getClient().dispatch();
    }
    
    m_readout.getNode("csr.ctrl.soft_rst").write(0x1);
    m_readout.getClient().dispatch();
 
    // time.sleep(0.1)
    std::this_thread::sleep_for (std::chrono::milliseconds(1));
 
 
    m_readout.getNode("csr.ctrl.soft_rst").write(0x0);
    m_readout.getClient().dispatch();
 
    // Check the ethernet core status
    auto eth_rdy = m_readout.getNode("tx_path.tx_mux.csr.stat.eth_rdy").read();
    m_readout.getClient().dispatch();
 
    // If the ethernet core is not ready, issue a phy reset
    if ( !eth_rdy ) {
      m_readout.getNode("pcs_pma.debug.csr.ctrl.phy_reset").write(0x1);
      m_readout.getNode("pcs_pma.debug.csr.ctrl.phy_reset").write(0x0);
      m_readout.getClient().dispatch();
    }
 
}

sel_tx_mux()

void dunedaq::hermesmodules::HermesCoreController::sel_tx_mux

(

uint16_t

i

)

Definition at line 71 of file HermesCoreController.cpp.

                                           {
  if ( i >= m_core_info.n_mgt ) {
    throw LinkDoesNotExist(ERS_HERE, i);
  }
 
  m_readout.getNode("tx_path.csr_tx_mux.ctrl.tx_mux_sel").write(i);
  m_readout.getClient().dispatch();
}

sel_tx_mux_buf()

void dunedaq::hermesmodules::HermesCoreController::sel_tx_mux_buf

(

uint16_t

i

)

Definition at line 83 of file HermesCoreController.cpp.

                                               {
  if ( i >= m_core_info.n_src ) {
    throw InputBufferDoesNotExist(ERS_HERE, i);
  }
 
  m_readout.getNode("tx_path.tx_mux.csr.ctrl.sel_buf").write(i);
  m_readout.getClient().dispatch();
}

sel_udp_core()

void dunedaq::hermesmodules::HermesCoreController::sel_udp_core

(

uint16_t

i

)

Definition at line 95 of file HermesCoreController.cpp.

                                             {
  if ( i >= m_core_info.n_mgt ) {
    throw MgtDoesNotExist(ERS_HERE, i);
  }
 
  m_readout.getNode("tx_path.csr_udp_core.ctrl.udp_core_sel").write(i);
  m_readout.getClient().dispatch();
}

Member Data Documentation

m_core_info

CoreInfo dunedaq::hermesmodules::HermesCoreController::m_core_info

private

Definition at line 103 of file HermesCoreController.hpp.

m_hw

uhal::HwInterface dunedaq::hermesmodules::HermesCoreController::m_hw

private

Definition at line 99 of file HermesCoreController.hpp.

m_readout

const uhal::Node& dunedaq::hermesmodules::HermesCoreController::m_readout

private

Definition at line 101 of file HermesCoreController.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/hermesmodules/include/hermesmodules/HermesCoreController.hpp
• /github/workspace/dunedaq/sourcecode/hermesmodules/src/HermesCoreController.cpp