dunedaq::timing::MasterNode Class Reference

Class for PD-II/DUNE master timing nodes. More...

#include <MasterNode.hpp>

Inheritance diagram for dunedaq::timing::MasterNode:

Collaboration diagram for dunedaq::timing::MasterNode:

Public Member Functions
	MasterNode (const uhal::Node &node)
virtual	~MasterNode ()
std::string	get_status (bool print_out=false) const override
	Print the status of the timing node.
std::string	get_status_with_date (uint32_t clock_frequency_hz, bool print_out=false) const
	Print the status of the timing node.
void	switch_endpoint_sfp (uint32_t address, bool turn_on) const override
	Control the tx line of endpoint sfp.
void	enable_upstream_endpoint () const override
	Enable RTT endpoint.
void	send_fl_cmd (uint32_t command, uint32_t channel, uint32_t number_of_commands=1) const override
	Send a fixed length command.
uint32_t	measure_endpoint_rtt (uint32_t address, bool control_sfp=true) const override
	Measure the endpoint round trip time.
void	apply_endpoint_delay (uint32_t address, uint32_t coarse_delay, uint32_t fine_delay, uint32_t phase_delay, bool measure_rtt=false, bool control_sfp=true) const override
	Apply delay to endpoint.
void	sync_timestamp (TimestampSource source) const override
	Set timestamp to current machine time.
uint64_t	read_timestamp () const override
	Read the current timestamp word.
void	set_timestamp (TimestampSource source) const override
	Set the timestamp to current time.
void	get_info (timingfirmwareinfo::MasterMonitorData &mon_data) const
	Fill the PD-I master monitoring structure.
void	reset_command_counters () const
	Read some data from endpoint registers.
std::vector< uint32_t >	transmit_async_packet (const std::vector< uint32_t > &packet, int timeout=500) const
	Send an async packet.
void	write_endpoint_data (uint16_t endpoint_address, uint8_t reg_address, std::vector< uint8_t > data, bool address_mode) const
	Write some data to endpoint registers.
std::vector< uint32_t >	read_endpoint_data (uint16_t endpoint_address, uint8_t reg_address, uint8_t data_length, bool address_mode) const
	Read some data from endpoint registers.
void	disable_timestamp_broadcast () const
	Disable timestamp sending.
void	enable_timestamp_broadcast () const
	Enable timestamp sending.
timingfirmware::EndpointCheckResult	scan_endpoint (uint16_t endpoint_address, bool control_sfp) const override
	Scan endpoint.
void	configure_endpoint_command_decoder (uint16_t endpoint_address, uint8_t slot, uint8_t command) const
	Configure endpoint command decoder.
uint32_t	get_required_major_firmware_version () const override
	Required major firmware version.
uint32_t	get_required_minor_firmware_version () const override
	Required minor firmware version.
uint32_t	get_required_patch_firmware_version () const override
	Required patch firmware version.
virtual void	apply_endpoint_delay (const ActiveEndpointConfig &ept_config, bool measure_rtt=false) const
	Apply delay to endpoint.
Public Member Functions inherited from dunedaq::timing::MasterNodeInterface
	MasterNodeInterface (const uhal::Node &node)
virtual	~MasterNodeInterface ()
virtual void	enable_periodic_fl_cmd (uint32_t channel, double rate, bool poisson, uint32_t clock_frequency_hz) const
	Configure fake trigger generator.
virtual void	enable_periodic_fl_cmd (uint32_t command, uint32_t channel, double rate, bool poisson, uint32_t clock_frequency_hz) const
	Configure fake trigger generator.
virtual void	disable_periodic_fl_cmd (uint32_t channel) const
	Clear fake trigger configuration.
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 Attributes
static const uint32_t	required_major_firmware_version = 7
static const uint32_t	required_minor_firmware_version = 7
static const uint32_t	required_patch_firmware_version = 0

Private Member Functions
std::string	get_status_tables () const
	Get the status tables.

Detailed Description

Class for PD-II/DUNE master timing nodes.

Definition at line 38 of file MasterNode.hpp.

Constructor & Destructor Documentation

MasterNode()

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

explicit

Definition at line 22 of file MasterNode.cpp.

  : MasterNodeInterface(node)
{}

~MasterNode()

dunedaq::timing::MasterNode::~MasterNode ( )

virtual

Definition at line 28 of file MasterNode.cpp.

{}

Member Function Documentation

apply_endpoint_delay() [1/2]

void dunedaq::timing::MasterNodeInterface::apply_endpoint_delay ( const ActiveEndpointConfig & ept_config, bool measure_rtt = false ) const

virtual

Apply delay to endpoint.

Reimplemented from dunedaq::timing::MasterNodeInterface.

Definition at line 94 of file MasterNodeInterface.cpp.

{
  std::string lEptIdD = ept_config.id;
  uint32_t ept_address = ept_config.adr;    // NOLINT(build/unsigned)
  uint32_t coarse_Delay = ept_config.cdelay; // NOLINT(build/unsigned)
  uint32_t fine_delay = ept_config.fdelay; // NOLINT(build/unsigned)
  uint32_t phase_delay = ept_config.pdelay; // NOLINT(build/unsigned)
  apply_endpoint_delay(ept_address, coarse_Delay, fine_delay, phase_delay, measure_rtt);
}

apply_endpoint_delay() [2/2]

void dunedaq::timing::MasterNode::apply_endpoint_delay ( uint32_t address, uint32_t coarse_delay, uint32_t fine_delay, uint32_t phase_delay, bool measure_rtt = false, bool control_sfp = true ) const

overridevirtual

Apply delay to endpoint.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 205 of file MasterNode.cpp.

{
 
  auto global = getNode<MasterGlobalNode>("global");
  auto echo = getNode<EchoMonitorNode>("echo_mon");
 
  if (measure_rtt) {
    if (control_sfp) {
      // Switch off all TX SFPs
      // switch_endpoint_sfp(0xffff, false);
 
      // Turn on the current target
      switch_endpoint_sfp(address, true);
 
      millisleep(100);
    }
 
    try
    {
      global.enable_upstream_endpoint();
    }
    catch (const timing::ReceiverNotReady& e)
    {
      if (control_sfp) {
        switch_endpoint_sfp(address, false);
      }
      throw e;
    }
 
    uint64_t endpoint_rtt = echo.send_echo_and_measure_delay(); // NOLINT(build/unsigned)
    TLOG() << "Pre delay adjustment RTT:  " << format_reg_value(endpoint_rtt, 10);
  }
 
  uint32_t sequence = 0xab;
  uint32_t address_mode = 1;
    
  std::vector<uint32_t> tx_packet = { address & 0xff, 
                                        address >> 8UL, 
                                        sequence,
 
                                        // packet to write coarse delay
                                        (0x1 << 7UL) | 0x72, // write transaction on 0x72
                                        (address_mode << 7UL) | 0x1, // transaction length of 0x1
                                        ((fine_delay & 0xf) << 4UL) | (coarse_delay & 0xf),
 
                                        // packet to write fine delay
                                        (0x1 << 7UL) | 0x73, // write transaction on 0x73
                                        (address_mode << 7UL) | 0x1, // transaction length of 0x1
                                        (fine_delay >> 4UL) & 0xff,
 
                                        // packet to set skew done
                                        (0x1 << 7UL) | 0x70, // write transaction on 0x70
                                        (address_mode << 7UL) | 0x1, // transaction length of 0x1
                                                0x3, // deskew done
 
                                        // packet to resync
                                        (0x1 << 7UL) | 0x70, // write transaction on 0x70
                                        (address_mode << 7UL) | 0x1, // transaction length of 0x1
                                                0x4, // resync
                                    };
 
  tx_packet.back() = tx_packet.back() | (0x1 << 8UL);
 
  transmit_async_packet(tx_packet, -1);
 
  if (measure_rtt) {
    try
    {
      global.enable_upstream_endpoint();
    }
    catch (const timing::ReceiverNotReady& e)
    {
      if (control_sfp)
      {
        switch_endpoint_sfp(address, false);
      }
      throw e;
    }
 
    uint64_t endpoint_rtt = echo.send_echo_and_measure_delay(); // NOLINT(build/unsigned)
    TLOG() << "Post delay adjustment RTT: " << format_reg_value(endpoint_rtt, 10);
 
    if (control_sfp)
      switch_endpoint_sfp(address, false);
  }
}

configure_endpoint_command_decoder()

void dunedaq::timing::MasterNode::configure_endpoint_command_decoder	(	uint16_t	endpoint_address,
		uint8_t	slot,
		uint8_t	command ) const

Configure endpoint command decoder.

Definition at line 596 of file MasterNode.cpp.

{
  write_endpoint_data(endpoint_address, 0x60+slot, {command}, true);
}

disable_timestamp_broadcast()

void dunedaq::timing::MasterNode::disable_timestamp_broadcast

(

)

const

Disable timestamp sending.

Definition at line 506 of file MasterNode.cpp.

{
  getNode("global.csr.ctrl.ts_en").write(0x0);
  getClient().dispatch();
}

enable_timestamp_broadcast()

void dunedaq::timing::MasterNode::enable_timestamp_broadcast

(

)

const

Enable timestamp sending.

Definition at line 514 of file MasterNode.cpp.

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

enable_upstream_endpoint()

void dunedaq::timing::MasterNode::enable_upstream_endpoint ( ) const

overridevirtual

Enable RTT endpoint.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 130 of file MasterNode.cpp.

{
  auto global = getNode<MasterGlobalNode>("global");
  global.enable_upstream_endpoint();
}

get_info()

void dunedaq::timing::MasterNode::get_info ( timingfirmwareinfo::MasterMonitorData & mon_data ) const

virtual

Fill the PD-I master monitoring structure.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 330 of file MasterNode.cpp.

{
  mon_data.timestamp = read_timestamp();
 
  auto control = read_sub_nodes(getNode("global.csr.ctrl"), false);
  auto state = read_sub_nodes(getNode("global.csr.stat"), false);
  getClient().dispatch();
 
  mon_data.ts_bcast_enable = control.at("ts_en").value();
  mon_data.ts_valid = state.at("ts_valid").value();
  mon_data.ts_tx_err = state.at("ts_tx_err").value();
  mon_data.tx_err = state.at("tx_err").value();
  mon_data.ctrs_rdy = state.at("ctrs_rdy").value();
 
//   ic.add(mon_data);
 
//   uint number_of_commands = 0xff;
 
//   getNode("cmd_ctrs.addr").write(0x0);
//   auto counters = getNode("cmd_ctrs.data").readBlock(number_of_commands);
//   getClient().dispatch();
 
//   for (uint i = 0; i < number_of_commands; ++i) { // NOLINT(build/unsigned)
 
//     timingfirmwareinfo::SentCommandCounter cmd_counter;
//     opmonlib::InfoCollector cmd_counter_ic;
 
//     cmd_counter.counts = counters.at(i);
 
//     std::stringstream channel;
//     channel << "cmd_0x" << std::hex << i;
 
//     cmd_counter_ic.add(cmd_counter);
//     ic.add(channel.str(), cmd_counter_ic);
//   }
 
//   getNode<FLCmdGeneratorNode>("scmd_gen").get_info(ic, level);
}

get_required_major_firmware_version()

uint32_t dunedaq::timing::MasterNode::get_required_major_firmware_version ( ) const

inlineoverridevirtual

Required major firmware version.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 156 of file MasterNode.hpp.

{ return required_major_firmware_version; }

get_required_minor_firmware_version()

uint32_t dunedaq::timing::MasterNode::get_required_minor_firmware_version ( ) const

inlineoverridevirtual

Required minor firmware version.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 161 of file MasterNode.hpp.

{ return required_minor_firmware_version; }

get_required_patch_firmware_version()

uint32_t dunedaq::timing::MasterNode::get_required_patch_firmware_version ( ) const

inlineoverridevirtual

Required patch firmware version.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 166 of file MasterNode.hpp.

{ return required_patch_firmware_version; }

get_status()

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

overridevirtual

Print the status of the timing node.

Implements dunedaq::timing::TimingNode.

Definition at line 77 of file MasterNode.cpp.

{
  std::stringstream status;
  auto raw_timestamp = getNode<TimestampGeneratorNode>("tstamp").read_raw_timestamp();
  status << "Timestamp: 0x" << std::hex << tstamp2int(raw_timestamp) << std::endl << std::endl;
  status << get_status_tables();
 
  if (print_out)
    TLOG() << status.str();
  return status.str();
}

get_status_tables()

std::string dunedaq::timing::MasterNode::get_status_tables ( ) const

private

Get the status tables.

Definition at line 33 of file MasterNode.cpp.

{
  std::stringstream status;
 
  status << getNode<TimestampGeneratorNode>("tstamp").get_status();
  status << std::endl;
 
  status << getNode<MasterGlobalNode>("global").get_status();
  status << std::endl;
 
  status << getNode<FLCmdGeneratorNode>("scmd_gen").get_cmd_counters_table();
  status << std::endl;
 
  getNode("cmd_ctrs.addr").write(0x0);
  auto counters = getNode("cmd_ctrs.data").readBlock(0xff);
  getClient().dispatch();
 
  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, { "Sent cmd counters" }, "Master cmd counters (>0)", counter_labels);
  status << std::endl;
 
  auto acmd_buf = read_sub_nodes(getNode("acmd_buf.stat"));
  status << format_reg_table(acmd_buf, "Master acmd buffer");
 
  return status.str();
}

get_status_with_date()

std::string dunedaq::timing::MasterNode::get_status_with_date	(	uint32_t	clock_frequency_hz,
		bool	print_out = false ) const

Print the status of the timing node.

Definition at line 92 of file MasterNode.cpp.

{
  std::stringstream status;
  auto raw_timestamp = getNode<TimestampGeneratorNode>("tstamp").read_raw_timestamp();
  status << "Timestamp: 0x" << std::hex << tstamp2int(raw_timestamp) << " -> " << format_timestamp(raw_timestamp, clock_frequency_hz) << std::endl
          << std::endl;
  status << get_status_tables();
 
  if (print_out)
    TLOG() << status.str();
  return status.str();
}

measure_endpoint_rtt()

uint32_t dunedaq::timing::MasterNode::measure_endpoint_rtt ( uint32_t address, bool control_sfp = true ) const

overridevirtual

Measure the endpoint round trip time.

Returns

{ description_of_the_return_value }

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 165 of file MasterNode.cpp.

{
 
  auto global = getNode<MasterGlobalNode>("global");
  auto echo = getNode<EchoMonitorNode>("echo_mon");
 
  if (control_sfp)
  {
    // Switch off all TX SFPs
    //switch_endpoint_sfp(0xffff, false);
 
    // Turn on the current target
    switch_endpoint_sfp(address, true);
 
    millisleep(100);
 
    try
    {
      global.enable_upstream_endpoint();
    }
    catch (const timing::ReceiverNotReady& e)
    {
      if (control_sfp) {
        switch_endpoint_sfp(address, false);
      }
      throw e;
    }
  }
 
  uint32_t endpoint_rtt = echo.send_echo_and_measure_delay(); // NOLINT(build/unsigned)
 
  if (control_sfp)
    switch_endpoint_sfp(address, false);
 
  return endpoint_rtt;
}

read_endpoint_data()

std::vector< uint32_t > dunedaq::timing::MasterNode::read_endpoint_data	(	uint16_t	endpoint_address,
		uint8_t	reg_address,
		uint8_t	data_length,
		bool	address_mode ) const

Read some data from endpoint registers.

Definition at line 475 of file MasterNode.cpp.

{
  if (data_length > 0x3f || data_length == 0)
  {
    TLOG() << "invalid data length";
    // TODO throw something
  }
 
  // TODO make sequence a function argument?
  uint32_t sequence = 0xab;
  std::vector<uint32_t> tx_packet = { static_cast<uint32_t>(endpoint_address & 0xff), 
                                      static_cast<uint32_t>(endpoint_address >> 8UL), 
                                      sequence,
                                      // bit 7 = 0 -> read
                                      reg_address,
                                      static_cast<uint32_t>((0x1 << 8UL) | (address_mode << 7UL) | (0x3f & data_length))
                                      };
 
  auto result = transmit_async_packet(tx_packet);
 
  // get parts we actually want
  std::vector<uint32_t> result_data (result.begin()+3, result.begin()+3+data_length);
  
  // strip off the bit 8 which is high for last byte
  result_data.back() = result_data.back() & 0xff;
 
  return result_data;
}

read_timestamp()

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

overridevirtual

Read the current timestamp word.

Returns

{ description_of_the_return_value }

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 314 of file MasterNode.cpp.

{
  return getNode<TimestampGeneratorNode>("tstamp").read_timestamp();
}

reset_command_counters()

void dunedaq::timing::MasterNode::reset_command_counters

(

)

const

Read some data from endpoint registers.

Definition at line 371 of file MasterNode.cpp.

{
  auto global = getNode<MasterGlobalNode>("global");
  global.reset_command_counters();
}

scan_endpoint()

timingfirmware::EndpointCheckResult dunedaq::timing::MasterNode::scan_endpoint ( uint16_t endpoint_address, bool control_sfp ) const

overridevirtual

Scan endpoint.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 523 of file MasterNode.cpp.

{
  timingfirmware::EndpointCheckResult result;
  auto global = getNode<MasterGlobalNode>("global");
  auto echo = getNode<EchoMonitorNode>("echo_mon");
 
  timingfirmware::EndpointCheckResult endpoint_result;
  endpoint_result.address = endpoint_address;
 
  // is endpoint sfp switched on?
  // are any relevant muxes set to correct channel?
  if (control_sfp)
  {
    switch_endpoint_sfp(endpoint_address, true);
 
    millisleep(100);
  }
 
  try
  {
    global.enable_upstream_endpoint();
  }
  catch (const timing::ReceiverNotReady& e)
  {
      switch_endpoint_sfp(endpoint_address, false);
 
      //ers::error(MonitoredEndpointDead(ERS_HERE, endpoint_address));
 
      return endpoint_result;
  }
 
  endpoint_result.alive = true;
  endpoint_result.round_trip_time = echo.send_echo_and_measure_delay();
  TLOG_DEBUG(5) << "Endpoint at address " << endpoint_address << " alive. RTT: " << endpoint_result.round_trip_time;
 
  auto ept_state = read_endpoint_data(endpoint_address, 0x71, 0x1, 0x1).at(0) & 0xf;
  TLOG_DEBUG(5) << "Endpoint at address " << endpoint_address << " state: 0x" << std::hex << ept_state;
  endpoint_result.state = ept_state;
 
  if (ept_state == 0x6)
  {
    TLOG_DEBUG(5) << "Endpoint at address " << endpoint_address << ", applying delays of: " << 0x0;
    ers::info(MonitoredEndpointDelaySet(ERS_HERE, 0x0, endpoint_address, ept_state));
    apply_endpoint_delay(endpoint_address, 0x0, 0x0, 0x0, false, false);
      
    endpoint_result.applied_delay = 0x0;
 
    auto ept_state_after_delays = read_endpoint_data(endpoint_address, 0x71, 0x1, 0x1).at(0) & 0xf;
    TLOG_DEBUG(5) << "Endpoint at address " << endpoint_address << ", state after delays apply: " << ept_state_after_delays;
    endpoint_result.state_after_delay_apply = ept_state_after_delays;
 
    endpoint_result.round_trip_time_after_delay_apply = echo.send_echo_and_measure_delay();
    TLOG_DEBUG(5) << "Endpoint at address " << endpoint_address << ", RTT after delays apply: " << endpoint_result.round_trip_time_after_delay_apply;
  }
  else if (ept_state == 0x7 || ept_state == 0x8)
  {
    TLOG_DEBUG(5) << "Endpoint at address " << endpoint_address << ", delays not needed";
  }
  else
  {
    ers::error(MonitoredEndpointUnexpectedState(ERS_HERE, endpoint_address, ept_state));
  }
 
  if (control_sfp)
  {
    switch_endpoint_sfp(endpoint_address, false);
  }
 
  return endpoint_result;
}

send_fl_cmd()

void dunedaq::timing::MasterNode::send_fl_cmd ( uint32_t command, uint32_t channel, uint32_t number_of_commands = 1 ) const

overridevirtual

Send a fixed length command.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 139 of file MasterNode.cpp.

{
  for (uint32_t i = 0; i < number_of_commands; i++) { // NOLINT(build/unsigned)
    getNode<FLCmdGeneratorNode>("scmd_gen").send_fl_cmd(command, channel);
    
    auto ts_l = getNode("cmd_log.tstamp_l").read();
    auto ts_h = getNode("cmd_log.tstamp_h").read();
    auto sent_cmd = getNode("cmd_log.cmd").read();
    getClient().dispatch();
 
    if (sent_cmd.value() != command)
    {
      TLOG() << "cmd in sent log: 0x" << std::hex << command << ", does not match requested 0x: " << sent_cmd.value();
      // TODO throw something
    }
    uint64_t timestamp = (uint64_t)ts_h.value() << 32 | ts_l.value();
    TLOG() << "Command sent " << "(" << format_reg_value(command) << ") from generator "
         << format_reg_value(channel) << " @time " << std::hex << std::showbase << timestamp;
  }
}

set_timestamp()

void dunedaq::timing::MasterNode::set_timestamp ( TimestampSource source ) const

overridevirtual

Set the timestamp to current time.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 322 of file MasterNode.cpp.

{
  getNode<TimestampGeneratorNode>("tstamp").set_timestamp(source);
}

switch_endpoint_sfp()

void dunedaq::timing::MasterNode::switch_endpoint_sfp ( uint32_t address, bool turn_on ) const

overridevirtual

Control the tx line of endpoint sfp.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 108 of file MasterNode.cpp.

{
    uint32_t sequence = 0xab;
    uint32_t address_mode = 1;
    
    std::vector<uint32_t> tx_packet = { address & 0xff, 
                                        address >> 8UL, 
                                        sequence,
 
                                        // packet to reset rx
                                        (0x1 << 7UL) | 0x70, // write transaction on 0x70
                                        (address_mode << 7UL) | 0x1, // transaction length of 0x1
                                        turn_on,
                                      };
  tx_packet.back() = tx_packet.back() | (0x1 << 8UL);
 
  auto result = transmit_async_packet(tx_packet, -1);
}

sync_timestamp()

void dunedaq::timing::MasterNode::sync_timestamp ( TimestampSource source ) const

overridevirtual

Set timestamp to current machine time.

Implements dunedaq::timing::MasterNodeInterface.

Definition at line 300 of file MasterNode.cpp.

{
  disable_timestamp_broadcast();
  TLOG() << "Timestamp broadcast disabled";
 
  set_timestamp(source);
 
  enable_timestamp_broadcast();
  TLOG() << "Timestamp broadcast enabled";
}

transmit_async_packet()

std::vector< uint32_t > dunedaq::timing::MasterNode::transmit_async_packet	(	const std::vector< uint32_t > &	packet,
		int	timeout = 500 ) const

Send an async packet.

Definition at line 380 of file MasterNode.cpp.

{
  // TODO: check for valid packet
 
  reset_sub_nodes(getNode("acmd_buf.txbuf"));
 
  TLOG_DEBUG(11) << "tx packet: ";
  for (auto t : packet)
    TLOG_DEBUG(11) << std::hex << "0x" << t;
 
  getNode("acmd_buf.txbuf").writeBlock(packet);
  getClient().dispatch();
 
  // we do not expect a reply
  if (timeout < 0)
  {
    std::vector<uint32_t> empty_vector;
    return empty_vector;
  }
 
  uhal::ValWord<uint32_t> buffer_ready;  // NOLINT(build/unsigned)
  uhal::ValWord<uint32_t> buffer_timeout;  // NOLINT(build/unsigned)
 
  // start time counting
  auto start = std::chrono::high_resolution_clock::now();
 
  // Wait for the buffer to be happy
  while (true) {
 
    buffer_ready = getNode("acmd_buf.stat.ready").read();
    buffer_timeout = getNode("acmd_buf.stat.timeout").read();
    getClient().dispatch();
    
    TLOG_DEBUG(10) << "async buffer ready: 0x" << buffer_ready.value() << ", timeout: " << buffer_timeout.value();
  
    if (buffer_timeout)
      throw VLCommandReplyTimeout(ERS_HERE);
     
    if (buffer_ready)
      break;
 
    auto now = std::chrono::high_resolution_clock::now();
    auto us_since_start = std::chrono::duration_cast<std::chrono::microseconds>(now - start);
 
    if (us_since_start.count() > timeout)
      throw VLCommandReplyBufferFlagTimeout(ERS_HERE, timeout);
 
    std::this_thread::sleep_for(std::chrono::microseconds(50));
  }
    
  auto rx_packet = getNode("acmd_buf.rxbuf").readBlock(0x20);
  getClient().dispatch();
 
  if (rx_packet.at(0) != 0xff || rx_packet.at(1) != 0xff || rx_packet.at(2) != packet.at(2))
  {
    ers::warning(InvalidVLCommandReplyPacket(ERS_HERE, rx_packet.at(0), rx_packet.at(1), rx_packet.at(2)));
  }
 
  TLOG_DEBUG(11) << "async result: ";
  for (auto r : rx_packet)
    TLOG_DEBUG(11) << std::hex << "0x" << r;
  
  return rx_packet.value();
}

write_endpoint_data()

void dunedaq::timing::MasterNode::write_endpoint_data	(	uint16_t	endpoint_address,
		uint8_t	reg_address,
		std::vector< uint8_t >	data,
		bool	address_mode ) const

Write some data to endpoint registers.

Definition at line 448 of file MasterNode.cpp.

{
  auto data_length = data.size();
  if (data_length > 0x3f || data_length == 0)
  {
    TLOG() << "invalid data length";
  }
 
  // TODO make sequence a function argument?
  uint32_t sequence = 0xab;
  
  std::vector<uint32_t> tx_packet = { static_cast<uint32_t>(endpoint_address & 0xff), 
                                      static_cast<uint32_t>(endpoint_address >> 8UL), 
                                      sequence, 
                                      // bit 7 = 1 -> write
                                      static_cast<uint32_t>((0x1 << 7UL) | reg_address),
                                       static_cast<uint32_t>((address_mode << 7UL) | (0x3f & data_length))
                                    };
  tx_packet.insert(tx_packet.end(), data.begin(), data.end());
  tx_packet.back() = tx_packet.back() | (0x1 << 8UL);
 
  auto result = transmit_async_packet(tx_packet);
}

Member Data Documentation

required_major_firmware_version

const uint32_t dunedaq::timing::MasterNode::required_major_firmware_version = 7

static

Definition at line 168 of file MasterNode.hpp.

required_minor_firmware_version

const uint32_t dunedaq::timing::MasterNode::required_minor_firmware_version = 7

static

Definition at line 169 of file MasterNode.hpp.

required_patch_firmware_version

const uint32_t dunedaq::timing::MasterNode::required_patch_firmware_version = 0

static

Definition at line 170 of file MasterNode.hpp.

---

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

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