Base class for timing IO nodes. More...

#include <IONode.hpp>

Inheritance diagram for dunedaq::timing::IONode:

Collaboration diagram for dunedaq::timing::IONode:

Public Member Functions
	IONode (const uhal::Node &node, std::string uid_i2c_bus, std::string pll_i2c_bus, std::string pll_i2c_device, std::vector< std::string > clock_names, std::vector< std::string > sfp_i2c_buses)

virtual	~IONode ()

virtual std::string	get_uid_address_parameter_name () const =0
	Get the UID address parameter name.

virtual uint32_t	read_board_type () const
	Read the word identifying the timing board.

virtual uint32_t	read_carrier_type () const
	Read the word identifying the FPFA carrier board.

virtual uint32_t	read_design_type () const
	Read the word identifying the firmware design in the FPGA.

virtual uint32_t	read_firmware_frequency () const
	Read the word identifying the frequency [units of Hz] of the firmware in the FPGA.

virtual uint64_t	read_board_uid () const
	Read the word containing the timing board UID.

virtual BoardRevision	get_board_revision () const
	Read the word identifying the timing board.

virtual std::string	get_hardware_info (bool print_out=false) const
	Print hardware information.

virtual std::string	get_full_clock_config_file_path (const ClockSource &clock_source) const
	Get the full config path.

template<class T >
std::unique_ptr< const T >	get_i2c_device (const std::string &i2c_bus_name, const std::string &i2c_device_name) const
	Get the an I2C chip.

virtual std::unique_ptr< const SI534xSlave >	get_pll () const
	Get the PLL chip.

virtual void	configure_pll (const std::string &clock_config_file="") const
	Configure clock chip.

virtual std::vector< double >	read_clock_frequencies () const
	Read frequencies of on-board clocks.

virtual std::string	get_clock_frequencies_table (bool print_out=false) const
	Print frequencies of on-board clocks.

virtual std::string	get_pll_status (bool print_out=false) const
	Print status of on-board PLL.

virtual std::string	get_sfp_status (uint32_t sfp_id, bool print_out=false) const
	Print status of on-board SFP.

virtual void	switch_sfp_soft_tx_control_bit (uint32_t sfp_id, bool turn_on) const
	control tx laser of on-board SFP softly (I2C command)

virtual void	switch_sfp_tx (uint32_t sfp_id, bool turn_on) const =0
	control tx laser of on-board SFP

virtual void	soft_reset () const
	Reset timing node.

virtual void	reset (const std::string &clock_config_file) const =0
	Reset timing node.

virtual void	reset (const ClockSource &clock_source) const
	Reset timing node with clock file lookup.

virtual bool	clocks_ok () const =0
	Clocks ready?

virtual void	get_info (timinghardwareinfo::TimingPLLMonitorData &mon_data) const

Public Member Functions inherited from dunedaq::timing::TimingNode
	TimingNode (const uhal::Node &node)

virtual	~TimingNode ()

virtual std::string	get_status (bool print_out=false) const =0
	Get the status string of the timing node. Optionally print it.

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 const std::map< BoardType, std::string > &	get_board_type_map ()

static const std::map< CarrierType, std::string > &	get_carrier_type_map ()

static const std::map< BoardRevision, std::string > &	get_board_revision_map ()

static const std::map< uint64_t, BoardRevision > &	get_board_uid_revision_map ()

static const std::map< DesignType, std::string > &	get_design_type_map ()

static const std::map< std::string, std::string > &	get_clock_config_map ()

static const std::vector< BoardType > &	get_library_supported_boards ()

static const std::vector< DesignType > &	get_library_supported_designs ()

Protected Member Functions
virtual void	write_soft_reset_register () const
	Write soft reset register.

Static Protected Member Functions
static std::string	clock_source_to_string (const ClockSource &source)

Protected Attributes
const std::string	m_uid_i2c_bus

const std::string	m_pll_i2c_bus

const std::string	m_pll_i2c_device

const std::vector< std::string >	m_clock_names

const std::vector< std::string >	m_sfp_i2c_buses

Static Protected Attributes
static const std::map< BoardType, std::string >	board_type_map

static const std::map< CarrierType, std::string >	carrier_type_map

static const std::map< BoardRevision, std::string >	board_revision_map

static const std::map< DesignType, std::string >	design_type_map

static const std::map< uint64_t, BoardRevision >	board_uid_revision_map

static const std::map< ClockSource, std::string >	clock_source_map

static const std::map< std::string, std::string >	clock_config_map

static const std::vector< BoardType >	library_supported_boards

static const std::vector< DesignType >	library_supported_designs

Detailed Description

Base class for timing IO nodes.

Definition at line 43 of file IONode.hpp.

Constructor & Destructor Documentation

◆ IONode()

dunedaq::timing::IONode::IONode	(	const uhal::Node &	node,
		std::string	uid_i2c_bus,
		std::string	pll_i2c_bus,
		std::string	pll_i2c_device,
		std::vector< std::string >	clock_names,
		std::vector< std::string >	sfp_i2c_buses )

Definition at line 25 of file IONode.cpp.

  : TimingNode(node)
  , m_uid_i2c_bus(uid_i2c_bus)
  , m_pll_i2c_bus(pll_i2c_bus)
  , m_pll_i2c_device(pll_i2c_device)
  , m_clock_names(clock_names)
  , m_sfp_i2c_buses(sfp_i2c_buses)
// mPLL (new SI534xSlave( getNode<I2CMasterNode>(m_pll_i2c_bus)& ,
// getNode<I2CMasterNode>(m_pll_i2c_bus).get_slave_address(pll_i2c_device) ))
{}

◆ ~IONode()

dunedaq::timing::IONode::~IONode ( )

virtual

Definition at line 43 of file IONode.cpp.

43{}

Member Function Documentation

◆ clock_source_to_string()

static std::string dunedaq::timing::IONode::clock_source_to_string ( const ClockSource & source )

inlinestaticprotected

Definition at line 428 of file IONode.hpp.

  {
     if (auto source_it = clock_source_map.find(source); source_it != clock_source_map.end())
     {
      return source_it->second;
     }
     else
     {
      throw MissingClockSourceMapEntry(ERS_HERE, format_reg_value(source));
     }
  }

◆ clocks_ok()

virtual bool dunedaq::timing::IONode::clocks_ok ( ) const

pure virtual

Clocks ready?

Implemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::FMCIONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

◆ configure_pll()

void dunedaq::timing::IONode::configure_pll ( const std::string & clock_config_file = "" ) const

virtual

Configure clock chip.

Reimplemented in dunedaq::timing::FIBV2IONode, dunedaq::timing::MIBIONode, and dunedaq::timing::SIMIONode.

Definition at line 247 of file IONode.cpp.

{
  auto pll = get_pll();
 
  TLOG() << "PLL configuration file : " << clock_config_file;
 
  uint32_t si_pll_version = pll->read_device_version(); // NOLINT(build/unsigned)
  TLOG_DEBUG(0) << "Configuring PLL        : SI" << format_reg_value(si_pll_version);
 
  pll->configure(clock_config_file);
 
  TLOG_DEBUG(0) << "PLL configuration id   : " << pll->read_config_id();
}

◆ get_board_revision()

BoardRevision dunedaq::timing::IONode::get_board_revision ( ) const

virtual

Read the word identifying the timing board.

Returns: { description_of_the_return_value }

Reimplemented in dunedaq::timing::SIMIONode.

Definition at line 104 of file IONode.cpp.

{
  auto uid = read_board_uid();
  try {
    return get_board_uid_revision_map().at(uid);
  } catch (const std::out_of_range& e) {
    ers::warning(UnknownBoardUID(ERS_HERE, format_reg_value(uid), e));
    return kBoardRevisionUnknown;
  }
}

◆ get_board_revision_map()

static const std::map< BoardRevision, std::string > & dunedaq::timing::IONode::get_board_revision_map ( )

inlinestatic

Definition at line 192 of file IONode.hpp.

192{ return board_revision_map; }

dunedaq::timing::IONode::board_revision_map

static const std::map< BoardRevision, std::string > board_revision_map

Definition IONode.hpp:232

◆ get_board_type_map()

static const std::map< BoardType, std::string > & dunedaq::timing::IONode::get_board_type_map ( )

inlinestatic

Definition at line 188 of file IONode.hpp.

188{ return board_type_map; }

dunedaq::timing::IONode::board_type_map

static const std::map< BoardType, std::string > board_type_map

Definition IONode.hpp:211

◆ get_board_uid_revision_map()

static const std::map< uint64_t, BoardRevision > & dunedaq::timing::IONode::get_board_uid_revision_map ( )

inlinestatic

Definition at line 193 of file IONode.hpp.

193{ return board_uid_revision_map; }

dunedaq::timing::IONode::board_uid_revision_map

static const std::map< uint64_t, BoardRevision > board_uid_revision_map

Definition IONode.hpp:259

◆ get_carrier_type_map()

static const std::map< CarrierType, std::string > & dunedaq::timing::IONode::get_carrier_type_map ( )

inlinestatic

Definition at line 190 of file IONode.hpp.

190{ return carrier_type_map; }

dunedaq::timing::IONode::carrier_type_map

static const std::map< CarrierType, std::string > carrier_type_map

Definition IONode.hpp:223

◆ get_clock_config_map()

static const std::map< std::string, std::string > & dunedaq::timing::IONode::get_clock_config_map ( )

inlinestatic

Definition at line 195 of file IONode.hpp.

195{ return clock_config_map; }

dunedaq::timing::IONode::clock_config_map

static const std::map< std::string, std::string > clock_config_map

Definition IONode.hpp:355

◆ get_clock_frequencies_table()

std::string dunedaq::timing::IONode::get_clock_frequencies_table ( bool print_out = false ) const

virtual

Print frequencies of on-board clocks.

Reimplemented in dunedaq::timing::FMCIONode, and dunedaq::timing::SIMIONode.

Definition at line 272 of file IONode.cpp.

{
  std::stringstream table;
  std::vector<double> frequencies = read_clock_frequencies();
  for (uint8_t i = 0; i < frequencies.size(); ++i) { // NOLINT(build/unsigned)
    table << m_clock_names.at(i) << " freq: " << std::setprecision(12) << frequencies.at(i) << std::endl;
  }
  // TODO add freq validation Stoyan Trilov stoyan.trilov@cern.ch
  if (print_out)
    TLOG() << table.str();
  return table.str();
}

◆ get_design_type_map()

static const std::map< DesignType, std::string > & dunedaq::timing::IONode::get_design_type_map ( )

inlinestatic

Definition at line 194 of file IONode.hpp.

194{ return design_type_map; }

dunedaq::timing::IONode::design_type_map

static const std::map< DesignType, std::string > design_type_map

Definition IONode.hpp:240

◆ get_full_clock_config_file_path()

std::string dunedaq::timing::IONode::get_full_clock_config_file_path ( const ClockSource & clock_source ) const

virtual

Get the full config path.

Returns: { description_of_the_return_value }

Definition at line 167 of file IONode.cpp.

{
  std::string config_file;
  std::stringstream clock_config_key;
 
  const BoardType board_type = convert_value_to_board_type(read_board_type());
//    const BoardRevision board_revision = get_board_revision();
  const CarrierType carrier_type = convert_value_to_carrier_type(read_carrier_type());
  const DesignType design_type = convert_value_to_design_type(read_design_type());
  //const uint32_t firmware_frequency = read_firmware_frequency(); // NOLINT(build/unsigned)
 
  try {
    clock_config_key << get_board_type_map().at(board_type) << "_";
  } catch (const std::out_of_range& e) {
    throw MissingBoardTypeMapEntry(ERS_HERE, format_reg_value(board_type), e);
  }
 
  // enclustra i2c switch stuff
  if (carrier_type == kCarrierEnclustraA35) {
    try {
      getNode<I2CMasterNode>(m_uid_i2c_bus).get_slave("AX3_Switch").write_i2c(0x01, 0x7f);
    } catch (const std::exception& e) {
      ers::warning(EnclustraSwitchFailure(ERS_HERE, e));
    }
  }
 
  auto pll = get_pll();
  auto pll_model = pll->read_device_version();
  clock_config_key << std::hex << pll_model;
 
//    try {
//      clock_config_key = clock_config_key + get_carrier_type_map().at(carrier_type) + "_";
//    } catch (const std::out_of_range& e) {
//      throw MissingCarrierTypeMapEntry(ERS_HERE, format_reg_value(carrier_type), e);
//    }
 
  try {
    clock_config_key << "_" << get_design_type_map().at(design_type);
  } catch (const std::out_of_range& e) {
    throw MissingDesignTypeMapEntry(ERS_HERE, format_reg_value(design_type), e);
  }
 
  clock_config_key << "_" << clock_source_to_string(clock_source);
 
  TLOG_DEBUG(0) << "Using pll config key: " << clock_config_key.str();
 
  try {
    config_file = get_clock_config_map().at(clock_config_key.str());
  } catch (const std::out_of_range& e) {
    throw ClockConfigNotFound(ERS_HERE, clock_config_key.str(), e);
  }
 
  TLOG_DEBUG(0) << "PLL config file: " << config_file << " from key: " << clock_config_key.str();
 
  const char* env_var_char = std::getenv("TIMING_SHARE");
 
  if (env_var_char == nullptr) {
    throw EnvironmentVariableNotSet(ERS_HERE, "TIMING_SHARE");
  }
 
  std::string env_var(env_var_char);
 
  std::string full_pll_config_file_path = env_var + "/config/etc/clock/" + config_file;
 
  TLOG_DEBUG(0) << "Full PLL config file path: " << full_pll_config_file_path;
 
  return full_pll_config_file_path;
}

◆ get_hardware_info()

std::string dunedaq::timing::IONode::get_hardware_info ( bool print_out = false ) const

virtual

Print hardware information.

Reimplemented in dunedaq::timing::GIBIONode, and dunedaq::timing::SIMIONode.

Definition at line 118 of file IONode.cpp.

{
  std::stringstream info;
  const BoardType board_type = convert_value_to_board_type(read_board_type());
  const BoardRevision board_revision = get_board_revision();
  const CarrierType carrier_type = convert_value_to_carrier_type(read_carrier_type());
  const DesignType design_type = convert_value_to_design_type(read_design_type());
  const double firmware_frequency = read_firmware_frequency()/1e6;
 
  std::vector<std::pair<std::string, std::string>> hardware_info;
 
  try {
    hardware_info.push_back(std::make_pair("Board type", get_board_type_map().at(board_type)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingBoardTypeMapEntry(ERS_HERE, format_reg_value(board_type), e));
  }
 
  try {
    hardware_info.push_back(std::make_pair("Board revision", get_board_revision_map().at(board_revision)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingBoardRevisionMapEntry(ERS_HERE, format_reg_value(board_revision), e));
  }
 
  hardware_info.push_back(std::make_pair("Board UID", format_reg_value(read_board_uid())));
 
  try {
    hardware_info.push_back(std::make_pair("Carrier type", get_carrier_type_map().at(carrier_type)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingCarrierTypeMapEntry(ERS_HERE, format_reg_value(carrier_type), e));
  }
 
  try {
    hardware_info.push_back(std::make_pair("Design type", get_design_type_map().at(design_type)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingDesignTypeMapEntry(ERS_HERE, format_reg_value(design_type), e));
  }
 
  hardware_info.push_back(std::make_pair("Firmware frequency [MHz]", std::to_string(firmware_frequency)));
 
  info << format_reg_table(hardware_info, "Hardware info", { "", "" });
 
  if (print_out)
    TLOG() << info.str();
  return info.str();
}

◆ get_i2c_device()

template<class T >

std::unique_ptr< const T > dunedaq::timing::IONode::get_i2c_device	(	const std::string &	i2c_bus_name,
		const std::string &	i2c_device_name ) const

Get the an I2C chip.

Returns: { description_of_the_return_value }

Definition at line 6 of file IONode.hxx.

{
  return std::unique_ptr<T>(new T(&getNode<I2CMasterNode>(i2c_bus_name),
                                  getNode<I2CMasterNode>(i2c_bus_name).get_slave_address(i2c_device_name)));
}

◆ get_info()

virtual void dunedaq::timing::IONode::get_info ( timinghardwareinfo::TimingPLLMonitorData & mon_data ) const

inlinevirtual

Reimplemented in dunedaq::timing::FIBV2IONode.

Definition at line 186 of file IONode.hpp.

186{get_pll()->get_info(mon_data);}

◆ get_library_supported_boards()

static const std::vector< BoardType > & dunedaq::timing::IONode::get_library_supported_boards ( )

inlinestatic

Definition at line 196 of file IONode.hpp.

196{ return library_supported_boards; }

dunedaq::timing::IONode::library_supported_boards

static const std::vector< BoardType > library_supported_boards

Definition IONode.hpp:420

◆ get_library_supported_designs()

static const std::vector< DesignType > & dunedaq::timing::IONode::get_library_supported_designs ( )

inlinestatic

Definition at line 197 of file IONode.hpp.

197{ return library_supported_designs; }

dunedaq::timing::IONode::library_supported_designs

static const std::vector< DesignType > library_supported_designs

Definition IONode.hpp:424

◆ get_pll()

std::unique_ptr< const SI534xSlave > dunedaq::timing::IONode::get_pll ( ) const

virtual

Get the PLL chip.

Returns: { description_of_the_return_value }

Reimplemented in dunedaq::timing::FIBV2IONode, and dunedaq::timing::GIBIONode.

Definition at line 239 of file IONode.cpp.

{
  return get_i2c_device<SI534xSlave>(m_pll_i2c_bus, m_pll_i2c_device);
}

◆ get_pll_status()

std::string dunedaq::timing::IONode::get_pll_status ( bool print_out = false ) const

virtual

Print status of on-board PLL.

Reimplemented in dunedaq::timing::FIBV2IONode, dunedaq::timing::MIBIONode, and dunedaq::timing::SIMIONode.

Definition at line 288 of file IONode.cpp.

{
  return get_pll()->get_status(print_out);
}

◆ get_sfp_status()

std::string dunedaq::timing::IONode::get_sfp_status	(	uint32_t	sfp_id,
		bool	print_out = false ) const

virtual

Print status of on-board SFP.

Reimplemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

Definition at line 324 of file IONode.cpp.

{
  std::stringstream status;
  std::string sfp_i2c_bus;
  try {
    sfp_i2c_bus = m_sfp_i2c_buses.at(sfp_id);
  } catch (const std::out_of_range& e) {
    throw InvalidSFPId(ERS_HERE, format_reg_value(sfp_id), e);
  }
  auto sfp = get_i2c_device<I2CSFPSlave>(sfp_i2c_bus, "SFP_EEProm");
  status << sfp->get_status();
  if (print_out)
    TLOG() << status.str();
  return status.str();
}

◆ get_uid_address_parameter_name()

virtual std::string dunedaq::timing::IONode::get_uid_address_parameter_name ( ) const

pure virtual

Get the UID address parameter name.

Returns: { description_of_the_return_value }

Implemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::FMCIONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

◆ read_board_type()

uint32_t dunedaq::timing::IONode::read_board_type ( ) const

virtual

Read the word identifying the timing board.

Returns: { description_of_the_return_value }

Definition at line 48 of file IONode.cpp.

{
  uhal::ValWord<uint32_t> board_type = getNode("config.board_type").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return board_type.value();
}

◆ read_board_uid()

uint64_t dunedaq::timing::IONode::read_board_uid ( ) const

virtual

Read the word containing the timing board UID.

Returns: { description_of_the_return_value }

Reimplemented in dunedaq::timing::SIMIONode.

Definition at line 88 of file IONode.cpp.

{
 
  uint64_t uid = 0;                // NOLINT(build/unsigned)
  std::vector<uint8_t> uid_values = // NOLINT(build/unsigned)
    getNode<I2CMasterNode>(m_uid_i2c_bus).get_slave(get_uid_address_parameter_name()).read_i2cArray(0xfa, 6);
 
  for (uint8_t i = 0; i < uid_values.size(); ++i) { // NOLINT(build/unsigned)
    uid = (uid << 8) | uid_values.at(i);
  }
  return uid;
}

◆ read_carrier_type()

uint32_t dunedaq::timing::IONode::read_carrier_type ( ) const

virtual

Read the word identifying the FPFA carrier board.

Returns: { description_of_the_return_value }

Definition at line 58 of file IONode.cpp.

{
  uhal::ValWord<uint32_t> carrier_type = getNode("config.carrier_type").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return carrier_type.value();
}

◆ read_clock_frequencies()

std::vector< double > dunedaq::timing::IONode::read_clock_frequencies ( ) const

virtual

Read frequencies of on-board clocks.

Reimplemented in dunedaq::timing::FMCIONode, and dunedaq::timing::SIMIONode.

Definition at line 264 of file IONode.cpp.

{
  return getNode<FrequencyCounterNode>("freq").measure_frequencies(m_clock_names.size());
}

◆ read_design_type()

uint32_t dunedaq::timing::IONode::read_design_type ( ) const

virtual

Read the word identifying the firmware design in the FPGA.

Returns: { description_of_the_return_value }

Definition at line 68 of file IONode.cpp.

{
  uhal::ValWord<uint32_t> design_type = getNode("config.design_type").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return design_type.value();
}

◆ read_firmware_frequency()

uint32_t dunedaq::timing::IONode::read_firmware_frequency ( ) const

virtual

Read the word identifying the frequency [units of Hz] of the firmware in the FPGA.

Returns: { description_of_the_return_value }

Definition at line 78 of file IONode.cpp.

{
  uhal::ValWord<uint32_t> firmware_frequency = getNode("config.clock_frequency").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return firmware_frequency.value();
}

◆ reset() [1/2]

void dunedaq::timing::IONode::reset ( const ClockSource & clock_source ) const

virtual

Reset timing node with clock file lookup.

Reimplemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::FMCIONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

Definition at line 314 of file IONode.cpp.

{
  // Find the right pll config file
  std::string clock_config = get_full_clock_config_file_path(clock_source);
  reset(clock_config);
}

◆ reset() [2/2]

virtual void dunedaq::timing::IONode::reset ( const std::string & clock_config_file ) const

pure virtual

Reset timing node.

Implemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::FMCIONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

◆ soft_reset()

void dunedaq::timing::IONode::soft_reset ( ) const

virtual

Reset timing node.

Definition at line 305 of file IONode.cpp.

{
  write_soft_reset_register();
  TLOG_DEBUG(0) << "Soft reset done";
}

◆ switch_sfp_soft_tx_control_bit()

void dunedaq::timing::IONode::switch_sfp_soft_tx_control_bit	(	uint32_t	sfp_id,
		bool	turn_on ) const

virtual

control tx laser of on-board SFP softly (I2C command)

Reimplemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

Definition at line 343 of file IONode.cpp.

{
  std::string sfp_i2c_bus;
  try {
    sfp_i2c_bus = m_sfp_i2c_buses.at(sfp_id);
  } catch (const std::out_of_range& e) {
    throw InvalidSFPId(ERS_HERE, format_reg_value(sfp_id), e);
  }
  auto sfp = get_i2c_device<I2CSFPSlave>(sfp_i2c_bus, "SFP_EEProm");
  sfp->switch_soft_tx_control_bit(turn_on);
}

◆ switch_sfp_tx()

virtual void dunedaq::timing::IONode::switch_sfp_tx	(	uint32_t	sfp_id,
		bool	turn_on ) const

pure virtual

control tx laser of on-board SFP

Implemented in dunedaq::timing::FIBIONode, dunedaq::timing::FIBV2IONode, dunedaq::timing::FMCIONode, dunedaq::timing::GIBIONode, dunedaq::timing::MIBIONode, dunedaq::timing::MIBV2IONode, dunedaq::timing::PC059IONode, dunedaq::timing::SIMIONode, and dunedaq::timing::TLUIONode.

◆ write_soft_reset_register()

void dunedaq::timing::IONode::write_soft_reset_register ( ) const

protectedvirtual

Write soft reset register.

Definition at line 296 of file IONode.cpp.

{
  getNode("csr.ctrl.soft_rst").write(0x1);
  getClient().dispatch();
}

Member Data Documentation

◆ board_revision_map

const std::map<BoardRevision, std::string> dunedaq::timing::IONode::board_revision_map

inlinestaticprotected

Initial value:

= {
                                                                { kFMCRev1, "kFMCRev1" },     { kFMCRev2, "kFMCRev2" }, { kFMCRev3, "kFMCRev3" },
                                                                { kPC059Rev1, "kPC059Rev1" }, { kTLURev1, "kTLURev1" }, { kSIMRev1, "kSIMRev1" },
                                                                { kFIBRev1, "kFIBRev1" }, { kFMCRev4, "kFMCRev4" }, { kMIBRev1, "kMIBRev1" },
                                                                { kPC069a, "pc069a" }, { kPC069b, "pc069b" }, { kPC069c, "pc069c" }, { kMIBRev2, "kMIBRev2" }, { kGIBRev1, "kGIBRev1" },
                                                                { kFIBRev2, "kFIBRev2" }, { kBoardRevisionUnknown, "unknown" }
  }

Definition at line 232 of file IONode.hpp.

                                                                            {
                                                                { kFMCRev1, "kFMCRev1" },     { kFMCRev2, "kFMCRev2" }, { kFMCRev3, "kFMCRev3" },
                                                                { kPC059Rev1, "kPC059Rev1" }, { kTLURev1, "kTLURev1" }, { kSIMRev1, "kSIMRev1" },
                                                                { kFIBRev1, "kFIBRev1" }, { kFMCRev4, "kFMCRev4" }, { kMIBRev1, "kMIBRev1" },
                                                                { kPC069a, "pc069a" }, { kPC069b, "pc069b" }, { kPC069c, "pc069c" }, { kMIBRev2, "kMIBRev2" }, { kGIBRev1, "kGIBRev1" },
                                                                { kFIBRev2, "kFIBRev2" }, { kBoardRevisionUnknown, "unknown" }
  };

◆ board_type_map

const std::map<BoardType, std::string> dunedaq::timing::IONode::board_type_map

inlinestaticprotected

Initial value:

= { { kBoardFMC, "fmc" },
                                                            { kBoardSim, "sim" },
                                                            { kBoardPC059, "pc059" },
                                                            { kBoardMicrozed, "microzed" },
                                                            { kBoardTLU, "tlu" },
                                                            { kBoardFIB, "fib" },
                                                            { kBoardMIB, "mib" },
                                                            { kBoardPC069, "pc069" },
                                                            { kBoardGIB, "gib" },
                                                            { kBoardUnknown, "unknown" }
                                                            }

Definition at line 211 of file IONode.hpp.

                                                                    { { kBoardFMC, "fmc" },
                                                            { kBoardSim, "sim" },
                                                            { kBoardPC059, "pc059" },
                                                            { kBoardMicrozed, "microzed" },
                                                            { kBoardTLU, "tlu" },
                                                            { kBoardFIB, "fib" },
                                                            { kBoardMIB, "mib" },
                                                            { kBoardPC069, "pc069" },
                                                            { kBoardGIB, "gib" },
                                                            { kBoardUnknown, "unknown" }
                                                            };

◆ board_uid_revision_map

const std::map<uint64_t, BoardRevision> dunedaq::timing::IONode::board_uid_revision_map

inlinestaticprotected

Definition at line 259 of file IONode.hpp.

                                                                               {
                                                                    { 0xd880395e720b, kFMCRev1 },
                                                                    { 0xd880395e501a, kFMCRev1 },
                                                                    { 0xd880395e50b8, kFMCRev1 },
                                                                    { 0xd880395e501b, kFMCRev1 },
                                                                    { 0xd880395e7201, kFMCRev1 },
                                                                    { 0xd880395e4fcc, kFMCRev1 },
                                                                    { 0xd880395e5069, kFMCRev1 },
                                                                    { 0xd880395e7206, kFMCRev1 },
                                                                    { 0xd880395e1c86, kFMCRev2 },
                                                                    { 0xd880395e2630, kFMCRev2 },
                                                                    { 0xd880395e262b, kFMCRev2 },
                                                                    { 0xd880395e2b38, kFMCRev2 },
                                                                    { 0xd880395e1a6a, kFMCRev2 },
                                                                    { 0xd880395e36ae, kFMCRev2 },
                                                                    { 0xd880395e2b2e, kFMCRev2 },
                                                                    { 0xd880395e2b33, kFMCRev2 },
                                                                    { 0xd880395e1c81, kFMCRev2 },
                                                                    { 0x049162b67ce6, kFMCRev3 },
                                                                    { 0x049162b62947, kFMCRev3 },
                                                                    { 0x049162b67cdf, kFMCRev3 },
                                                                    { 0x49162b62050, kFMCRev3 },
                                                                    { 0x49162b62951, kFMCRev3 },
                                                                    { 0x49162b675e3, kFMCRev3 },
                                                                    { 0xd88039d980cf, kPC059Rev1 },
                                                                    { 0xd88039d98adf, kPC059Rev1 },
                                                                    { 0xd88039d92491, kPC059Rev1 },
                                                                    { 0xd88039d9248e, kPC059Rev1 },
                                                                    { 0xd88039d98ae9, kPC059Rev1 },
                                                                    { 0xd88039d92498, kPC059Rev1 },
                                                                    { 0x5410ecbba408, kTLURev1 },
                                                                    { 0x5410ecbb9426, kTLURev1 },
                                                                    { 0x801f12f5ce48, kFIBRev1 },
                                                                    { 0x801f12f5e9ae, kFIBRev1 },
                                                                    { 0x49162b65025, kFMCRev3 },
                                                                    { 0x49162b62948, kFMCRev3 },
                                                                    { 0x49162b675ea, kFMCRev3 },
                                                                    { 0x49162b645cd, kFMCRev3 },
                                                                    { 0xd880395dab52, kFMCRev4 },
                                                                    { 0xd880395d99b3, kFMCRev4 },
                                                                    { 0xd880395df010, kFMCRev4 },
                                                                    { 0xd880395df00f, kFMCRev4 },
                                                                    { 0xd880395de4a4, kFMCRev4 },
                                                                    { 0xd880395d99a9, kFMCRev4 },
                                                                    { 0xd880395d99b0, kFMCRev4 },
                                                                    { 0xd880395de452, kFMCRev4 },
                                                                    { 0xd880395da48e, kFMCRev4 },
                                                                    { 0xd880395dbcee, kFMCRev4 },
                                                                    { 0x803428749c04, kPC069a  },
                                                                    { 0x5410ecbb6845, kTLURev1 },
                                                                    { 0x801f12ee6739, kMIBRev1 },
                                                                    { 0x801f12f5e183, kFIBRev1 },
                                                                    { 0x49162b1d910,  kMIBRev2 },
                                                                    { 0x801f12ee56f3, kGIBRev1 },
                                                                    { 0x80342874c33d, kPC069a },
                                                                    { 0x803428748902, kPC069a },
                                                                    { 0x8034287498ea, kPC069a },
                                                                    { 0xfc0fe700bece, kPC069b },
                                                                    { 0xfc0fe700c286, kPC069b },
                                                                    { 0xfc0fe700d293, kPC069b },
                                                                    { 0xfc0fe700bec4, kPC069b },
                                                                    { 0xfc0fe700c281, kPC069b },
                                                                    { 0xfc0fe700bec9, kPC069b },
                                                                    { 0xfc0fe700d28e, kPC069b },
                                                                    { 0xfc0fe700d289, kPC069b },
                                                                    { 0xfc0fe700d298, kPC069b },
                                                                    { 0xfc0fe700c28b, kPC069b },
                                                                    { 0xfc0fe7ea5d1e, kPC069b },
                                                                    { 0x049162b1d4bf, kMIBRev2 },
                                                                    { 0xfc0fe7ea5d1e, kPC069c },
                                                                    { 0xfc0fe7ea9113, kPC069c }, 
                                                                    { 0xfc0fe7ea5d28, kPC069c }, 
                                                                    { 0xfc0fe7eaa20c, kPC069c }, 
                                                                    { 0xfc0fe7ea51e4, kPC069c }, 
                                                                    { 0xfc0fe7ea6251, kPC069c }, 
                                                                    { 0xfc0fe7ea51da, kPC069c }, 
                                                                    { 0xfc0fe7ea5d2d, kPC069c }, 
                                                                    { 0xfc0fe7ea9112, kPC069c }, 
                                                                    { 0xfc0fe7ea51df, kPC069c },
                                                                    { 0xfc0fe7eaa202, kPC069c }, 
                                                                    { 0xfc0fe7ea5d23, kPC069c }, 
                                                                    { 0xfc0fe7eaa203, kPC069c }, 
                                                                    { 0xfc0fe7eaa20d, kPC069c }, 
                                                                    { 0xfc0fe7ea6256, kPC069c },
                                                                    { 0xd8478fa99d2d, kPC069b },
                                                                    { 0xd8478fa99b57, kPC069b },
  };  

◆ carrier_type_map

const std::map<CarrierType, std::string> dunedaq::timing::IONode::carrier_type_map

inlinestaticprotected

Initial value:

= { { kCarrierEnclustraA35, "enclustra-a35" },
                                                                { kCarrierKC705, "kc705" },
                                                                { kCarrierMicrozed, "microzed" },
                                                                { kCarrierATFC, "atfc" },
                                                                { kCarrierAFC, "afc" },
                                                                { kCarrierNexusVideo, "nexus-video" },
                                                                { kCarrierTrenzTE0712, "trenz-te0712" },
                                                                { kCarrierUnknown, "unknown" }
                                                                }

Definition at line 223 of file IONode.hpp.

                                                                        { { kCarrierEnclustraA35, "enclustra-a35" },
                                                                { kCarrierKC705, "kc705" },
                                                                { kCarrierMicrozed, "microzed" },
                                                                { kCarrierATFC, "atfc" },
                                                                { kCarrierAFC, "afc" },
                                                                { kCarrierNexusVideo, "nexus-video" },
                                                                { kCarrierTrenzTE0712, "trenz-te0712" },
                                                                { kCarrierUnknown, "unknown" }
                                                                };

◆ clock_config_map

const std::map<std::string, std::string> dunedaq::timing::IONode::clock_config_map

inlinestaticprotected

Definition at line 355 of file IONode.hpp.

                                                                      {
 
        // 62.5 MHz mappings (no cdr)
        { "fmc_5344_ouroboros_free_run", "SI5344/PDTS0003.txt" },
        { "fmc_5394_ouroboros_free_run", "SI5344/PDTS0003.txt" },
 
        { "fmc_5344_master_free_run", "SI5344/PDTS0003.txt" },
        { "fmc_5394_master_free_run", "SI5344/PDTS0003.txt" },
 
        { "fmc_5344_overlord_free_run", "SI5344/PDTS0003.txt" },
        { "fmc_5394_overlord_free_run", "SI5344/PDTS0003.txt" },
 
        { "fmc_5344_boreas_free_run", "SI5344/PDTS0003.txt" },
        { "fmc_5394_boreas_free_run", "SI5344/PDTS0003.txt" },
 
        { "fmc_5344_endpoint_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
        { "fmc_5394_endpoint_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
 
        { "fmc_5344_chronos_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
        { "fmc_5394_chronos_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
 
        { "fmc_5344_charon_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
        { "fmc_5394_charon_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
 
        { "fmc_5344_hades_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
        { "fmc_5394_hades_input_1", "devel/ENDPOINT-Si5344-50MHzRef.txt" },
 
        { "tlu_5345_boreas_free_run", "nocdr/DUNE_TLU-4_45_M-Registers.txt" },
 
        { "pc059_5345_master_free_run", "devel/PDTS_PC059_FANOUT.txt" },
        { "pc059_5345_fanout_input_1", "devel/PDTS_PC059_FANOUT_SFP_IN.txt" },
 
        { "pc069_5395_master_free_run", "nocdr/Si5395-RevA-069a_mst-Registers.txt" },
        { "pc069_5395_boreas_free_run", "nocdr/Si5395-RevA-069a_mst-Registers.txt" },
 
        { "pc069_5395_endpoint_input_1", "nocdr/Si5395-RevA-069a_ep-Registers.txt" },
        { "pc069_5395_chronos_input_1", "nocdr/Si5395-RevA-069a_ep-Registers.txt" },
        { "pc069_5395_charon_input_1", "nocdr/Si5395-RevA-069a_ep-Registers.txt" },
        { "pc069_5395_hades_input_1", "nocdr/Si5395-RevA-069a_ep-Registers.txt" },
 
        { "pc069_5345_master_free_run", "nocdr/Si5345-RevD-pc69bmst-Registers.txt" },
        { "pc069_5345_boreas_free_run", "nocdr/Si5345-RevD-pc69bmst-Registers.txt" },
 
        { "pc069_5345_chronos_input_1", "nocdr/Si5345-RevD-pc69bept-Registers.txt" },
        { "pc069_5345_charon_input_1", "nocdr/Si5345-RevD-pc69bept-Registers.txt" },
        { "pc069_5345_endpoint_input_1", "nocdr/Si5345-RevD-pc69bept-Registers.txt" },
        { "pc069_5345_hades_input_1", "nocdr/Si5345-RevD-pc69bept-Registers.txt" },
 
        { "gib_5395_gaia_free_run", "nocdr/GIB_Debug_01.txt" },
 
        { "gib_5395_gaia_input_0", "nocdr/Si5395-RevA-GIB10MHZ-Registers.txt" },
 
        { "mib_5395_kerberos_free_run",
          "nocdr/Si5395-RevA-MIB_FREE-Registers.txt" },
        { "mib_5395_kerberos_input_0",
          "nocdr/Si5395-RevA-MIB_INSW-Registers.txt" },
        { "mib_5395_kerberos_input_1",
          "nocdr/Si5395-RevA-MIB_INSW-Registers.txt" },
        { "mib_5395_kerberos_input_2",
          "nocdr/Si5395-RevA-MIB_INSW-Registers.txt" },
 
        { "fib_5395_fanout_input_1",
          "nocdr/Si5395-RevA-FIB_FAN_AFCv4-FIBBP250-Registers.txt" }, // fanout design, data and clock from backplane
  };

◆ clock_source_map

const std::map<ClockSource, std::string> dunedaq::timing::IONode::clock_source_map

inlinestaticprotected

Initial value:

= {
                                                            { kFreeRun, "free_run" },
                                                            { kInput0, "input_0" },
                                                            { kInput1, "input_1" },
                                                            { kInput2, "input_2" },
                                                            { kInput3, "input_3" },
                                                            }

Definition at line 347 of file IONode.hpp.

                                                                        {
                                                            { kFreeRun, "free_run" },
                                                            { kInput0, "input_0" },
                                                            { kInput1, "input_1" },
                                                            { kInput2, "input_2" },
                                                            { kInput3, "input_3" },
                                                            };

◆ design_type_map

const std::map<DesignType, std::string> dunedaq::timing::IONode::design_type_map

inlinestaticprotected

Initial value:

= {
                                                                { kDesignMaster, "master" },
                                                                { kDesignOuroboros, "ouroboros" },
                                                                { kDesignOuroborosSim, "ouroboros-sim" },
                                                                { kDesignTest, "test-design" },
                                                                { kDesignEndpoint, "endpoint" },
                                                                { kDesignFanout, "fanout" },
                                                                { kDesignOverlord, "overlord" },
                                                                { kDesignEndpoBICRT, "endpoint-bi-crt" },
                                                                { kDesignChronos, "chronos" },
                                                                { kDesignBoreas, "boreas" },
                                                                { kDesignKerberos, "kerberos" },
                                                                { kDesignGaia, "gaia" },
                                                                { kDesignCharon, "charon" },
                                                                { kDesignHades, "hades" },
                                                                { kDesignUnknown, "unknown" },
  }

Definition at line 240 of file IONode.hpp.

                                                                      {
                                                                { kDesignMaster, "master" },
                                                                { kDesignOuroboros, "ouroboros" },
                                                                { kDesignOuroborosSim, "ouroboros-sim" },
                                                                { kDesignTest, "test-design" },
                                                                { kDesignEndpoint, "endpoint" },
                                                                { kDesignFanout, "fanout" },
                                                                { kDesignOverlord, "overlord" },
                                                                { kDesignEndpoBICRT, "endpoint-bi-crt" },
                                                                { kDesignChronos, "chronos" },
                                                                { kDesignBoreas, "boreas" },
                                                                { kDesignKerberos, "kerberos" },
                                                                { kDesignGaia, "gaia" },
                                                                { kDesignCharon, "charon" },
                                                                { kDesignHades, "hades" },
                                                                { kDesignUnknown, "unknown" },
  };

◆ library_supported_boards

const std::vector<BoardType> dunedaq::timing::IONode::library_supported_boards

inlinestaticprotected

Initial value:

= {
    kBoardFMC, kBoardPC059, kBoardTLU, kBoardSim, kBoardFIB, kBoardMIB, kBoardPC069, kBoardGIB
  }

Definition at line 420 of file IONode.hpp.

                                                                      {
    kBoardFMC, kBoardPC059, kBoardTLU, kBoardSim, kBoardFIB, kBoardMIB, kBoardPC069, kBoardGIB
  };

◆ library_supported_designs

const std::vector<DesignType> dunedaq::timing::IONode::library_supported_designs

inlinestaticprotected

Initial value:

= {
    kDesignMaster, kDesignOuroboros, kDesignOuroborosSim, kDesignEndpoint, kDesignFanout, kDesignOverlord, kDesignEndpoBICRT, kDesignChronos, kDesignBoreas, kDesignKerberos, kDesignGaia
  }

Definition at line 424 of file IONode.hpp.

                                                                        {
    kDesignMaster, kDesignOuroboros, kDesignOuroborosSim, kDesignEndpoint, kDesignFanout, kDesignOverlord, kDesignEndpoBICRT, kDesignChronos, kDesignBoreas, kDesignKerberos, kDesignGaia
  };

◆ m_clock_names

const std::vector<std::string> dunedaq::timing::IONode::m_clock_names

protected

Definition at line 203 of file IONode.hpp.

◆ m_pll_i2c_bus

const std::string dunedaq::timing::IONode::m_pll_i2c_bus

protected

Definition at line 201 of file IONode.hpp.

◆ m_pll_i2c_device

const std::string dunedaq::timing::IONode::m_pll_i2c_device

protected

Definition at line 202 of file IONode.hpp.

◆ m_sfp_i2c_buses

const std::vector<std::string> dunedaq::timing::IONode::m_sfp_i2c_buses

protected

Definition at line 204 of file IONode.hpp.

◆ m_uid_i2c_bus

const std::string dunedaq::timing::IONode::m_uid_i2c_bus

protected

Definition at line 200 of file IONode.hpp.

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

/github/workspace/dunedaq/sourcecode/timing/include/timing/IONode.hpp
/github/workspace/dunedaq/sourcecode/timing/include/timing/detail/IONode.hxx
/github/workspace/dunedaq/sourcecode/timing/src/IONode.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ IONode()

◆ ~IONode()

Member Function Documentation

◆ clock_source_to_string()

◆ clocks_ok()

◆ configure_pll()

◆ get_board_revision()

◆ get_board_revision_map()

◆ get_board_type_map()

◆ get_board_uid_revision_map()

◆ get_carrier_type_map()

◆ get_clock_config_map()

◆ get_clock_frequencies_table()

◆ get_design_type_map()

◆ get_full_clock_config_file_path()

◆ get_hardware_info()

◆ get_i2c_device()

◆ get_info()

◆ get_library_supported_boards()

◆ get_library_supported_designs()

◆ get_pll()

◆ get_pll_status()

◆ get_sfp_status()

◆ get_uid_address_parameter_name()

◆ read_board_type()

◆ read_board_uid()

◆ read_carrier_type()

◆ read_clock_frequencies()

◆ read_design_type()

◆ read_firmware_frequency()

◆ reset() [1/2]

◆ reset() [2/2]

◆ soft_reset()

◆ switch_sfp_soft_tx_control_bit()

◆ switch_sfp_tx()

◆ write_soft_reset_register()

Member Data Documentation

◆ board_revision_map

◆ board_type_map

◆ board_uid_revision_map

◆ carrier_type_map

◆ clock_config_map

◆ clock_source_map

◆ design_type_map

◆ library_supported_boards

◆ library_supported_designs

◆ m_clock_names

◆ m_pll_i2c_bus

◆ m_pll_i2c_device

◆ m_sfp_i2c_buses

◆ m_uid_i2c_bus