docs/io_8cpp_source.html

#include "timing/FMCIONode.hpp"

#include "timing/IONode.hpp"

#include "timing/PC059IONode.hpp"

#include "timing/FIBIONode.hpp"

#include "timing/FIBV2IONode.hpp"

#include "timing/SIMIONode.hpp"

#include "timing/TLUIONode.hpp"

#include "timing/MIBIONode.hpp"

#include "timing/SwitchyardNode.hpp"

#include "timing/MIBV2IONode.hpp"

#include "timing/GIBIONode.hpp"

#include "timing/GIBV2IONode.hpp"


#include <pybind11/pybind11.h>

#include <pybind11/stl.h>


#include <string>


namespace py = pybind11;


namespace dunedaq {

namespace timing {

namespace python {


void


register_io(py::module& m)

{


  py::class_<timing::IONode, uhal::Node>(m, "IONode");


  py::class_<timing::FMCIONode, timing::IONode, uhal::Node>(m, "FMCIONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::FMCIONode::*)(const std::string&) const>(

      "reset", &timing::FMCIONode::reset, py::arg("clock_config_file"))

    .def<void (timing::FMCIONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::FMCIONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::FMCIONode::soft_reset)

    .def("read_firmware_frequency", &timing::FMCIONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::FMCIONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::FMCIONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::FMCIONode::get_pll_status, py::arg("print_out") = false)

    .def("get_hardware_info", &timing::FMCIONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::FMCIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::FMCIONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_tx", &timing::FMCIONode::switch_sfp_tx);


  py::class_<timing::PC059IONode, timing::IONode, uhal::Node>(m, "PC059IONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::PC059IONode::*)(const std::string&) const>(

      "reset", &timing::PC059IONode::reset, py::arg("clock_config_file"))

    .def<void (timing::PC059IONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::PC059IONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::PC059IONode::soft_reset)

    .def("read_firmware_frequency", &timing::PC059IONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::PC059IONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::PC059IONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::PC059IONode::get_pll_status, py::arg("print_out") = false)

    .def("get_hardware_info", &timing::PC059IONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::PC059IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::PC059IONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_mux_channel", &timing::PC059IONode::switch_sfp_mux_channel, py::arg("mux_channel"))

    .def("read_active_sfp_mux_channel", &timing::PC059IONode::read_active_sfp_mux_channel)

    .def("switch_sfp_tx", &timing::PC059IONode::switch_sfp_tx);


    py::class_<timing::FIBIONode, timing::IONode, uhal::Node>(m, "FIBIONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::FIBIONode::*)(const std::string&) const>(

      "reset", &timing::FIBIONode::reset, py::arg("clock_config_file"))

    .def<void (timing::FIBIONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::FIBIONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::FIBIONode::soft_reset)

    .def("read_firmware_frequency", &timing::FIBIONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::FIBIONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::FIBIONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::FIBIONode::get_pll_status, py::arg("print_out") = false)

    .def("get_hardware_info", &timing::FIBIONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::FIBIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::FIBIONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_mux_channel", &timing::FIBIONode::switch_sfp_mux_channel, py::arg("mux_channel"))

    .def("read_active_sfp_mux_channel", &timing::FIBIONode::read_active_sfp_mux_channel)

    .def("switch_sfp_tx", &timing::FIBIONode::switch_sfp_tx);


    py::class_<timing::FIBV2IONode, timing::IONode, uhal::Node>(m, "FIBV2IONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::FIBV2IONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::FIBV2IONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::FIBV2IONode::soft_reset)

    .def("read_firmware_frequency", &timing::FIBV2IONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::FIBV2IONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::FIBV2IONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::FIBV2IONode::get_pll_status, py::arg("print_out") = false)

    .def("get_hardware_info", &timing::FIBV2IONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::FIBV2IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::FIBV2IONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_tx", &timing::FIBV2IONode::switch_sfp_tx)

    .def("read_board_temperature", &timing::FIBV2IONode::read_board_temperature)

    ;


  py::class_<timing::TLUIONode, timing::IONode, uhal::Node>(m, "TLUIONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::TLUIONode::*)(const std::string&) const>(

      "reset", &timing::TLUIONode::reset, py::arg("clock_config_file"))

    .def<void (timing::TLUIONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::TLUIONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::TLUIONode::soft_reset)

    .def("read_firmware_frequency", &timing::TLUIONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::TLUIONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::TLUIONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::TLUIONode::get_pll_status, py::arg("print_out") = false)

    .def("get_hardware_info", &timing::TLUIONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::TLUIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::TLUIONode::switch_sfp_soft_tx_control_bit)

    .def("configure_dac",

         &timing::TLUIONode::configure_dac,

         py::arg("dac_id"),

         py::arg("dac_value"),

         py::arg("internal_ref") = false)

    .def("switch_sfp_tx", &timing::TLUIONode::switch_sfp_tx);


  py::class_<timing::SIMIONode, timing::IONode, uhal::Node>(m, "SIMIONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::SIMIONode::*)(const std::string&) const>(

      "reset", &timing::SIMIONode::reset, py::arg("clock_config_file"))

    .def<void (timing::SIMIONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::SIMIONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::SIMIONode::soft_reset)

    .def("read_firmware_frequency", &timing::SIMIONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::SIMIONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::SIMIONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::SIMIONode::get_pll_status, py::arg("print_out") = false)

    .def("get_hardware_info", &timing::SIMIONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::SIMIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::SIMIONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_tx", &timing::SIMIONode::switch_sfp_tx);


  py::class_<timing::MIBIONode, timing::IONode, uhal::Node>(m, "MIBIONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::MIBIONode::*)(const std::string&) const>(

      "reset", &timing::MIBIONode::reset, py::arg("clock_config_file"))

    .def<void (timing::MIBIONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::MIBIONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::MIBIONode::soft_reset)

    .def("read_firmware_frequency", &timing::MIBIONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::MIBIONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::MIBIONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::MIBIONode::get_pll_status, py::arg("print_out") = false)

    .def("get_pll", &timing::MIBIONode::get_pll)

    .def("get_hardware_info", &timing::MIBIONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::MIBIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::MIBIONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_tx", &timing::MIBIONode::switch_sfp_tx)

    ;


    py::class_<timing::SwitchyardNode, uhal::Node>(m, "SwitchyardNode")

      .def("get_status", &timing::SwitchyardNode::get_status, py::arg("print_out") = false)

      .def("configure_master_source", &timing::SwitchyardNode::configure_master_source, py::arg("master_source"), py::arg("dispatch") = true)

      .def("configure_endpoint_source", &timing::SwitchyardNode::configure_endpoint_source, py::arg("endpoint_source"), py::arg("dispatch") = true);


    py::class_<timing::MIBV2IONode, timing::IONode, uhal::Node>(m, "MIBV2IONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::MIBV2IONode::*)(const std::string&) const>(

      "reset", &timing::MIBV2IONode::reset, py::arg("clock_config_file"))

    .def<void (timing::MIBV2IONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::MIBV2IONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::MIBV2IONode::soft_reset)

    .def("read_firmware_frequency", &timing::MIBV2IONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::MIBV2IONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::MIBV2IONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::MIBV2IONode::get_pll_status, py::arg("print_out") = false)

    .def("get_pll", &timing::MIBV2IONode::get_pll)

    .def("get_hardware_info", &timing::MIBV2IONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::MIBV2IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::MIBV2IONode::switch_sfp_soft_tx_control_bit)

    .def("switch_sfp_tx", &timing::MIBV2IONode::switch_sfp_tx)

    ;


    py::class_<timing::GIBIONode, timing::IONode, uhal::Node>(m, "GIBIONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::GIBIONode::*)(const std::string&) const>(

      "reset", &timing::GIBIONode::reset, py::arg("clock_config_file"))

    .def<void (timing::GIBIONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::GIBIONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::GIBIONode::soft_reset)

    .def("read_firmware_frequency", &timing::GIBIONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::GIBIONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::GIBIONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::GIBIONode::get_pll_status, py::arg("print_out") = false)

    .def("get_pll", &timing::GIBIONode::get_pll)

    .def("get_hardware_info", &timing::GIBIONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::GIBIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::GIBIONode::switch_sfp_soft_tx_control_bit)

    .def("set_i2c_mux_channels", &timing::GIBIONode::set_i2c_mux_channels)

    .def("switch_sfp_tx", &timing::GIBIONode::switch_sfp_tx)

    ;


    py::class_<timing::GIBV2IONode, timing::IONode, uhal::Node>(m, "GIBV2IONode")

    .def(py::init<const uhal::Node&>())

    .def<void (timing::GIBV2IONode::*)(const std::string&) const>(

      "reset", &timing::GIBV2IONode::reset, py::arg("clock_config_file"))

    .def<void (timing::GIBV2IONode::*)(const timing::ClockSource&) const>(

      "reset", &timing::GIBV2IONode::reset, py::arg("clock_source"))

    .def("soft_reset", &timing::GIBV2IONode::soft_reset)

    .def("read_firmware_frequency", &timing::GIBV2IONode::read_firmware_frequency)

    .def("get_clock_frequencies_table", &timing::GIBV2IONode::get_clock_frequencies_table, py::arg("print_out") = false)

    .def("get_status", &timing::GIBV2IONode::get_status, py::arg("print_out") = false)

    .def("get_pll_status", &timing::GIBV2IONode::get_pll_status, py::arg("print_out") = false)

    .def("get_pll", &timing::GIBV2IONode::get_pll)

    .def("get_hardware_info", &timing::GIBV2IONode::get_hardware_info, py::arg("print_out") = false)

    .def("get_sfp_status", &timing::GIBV2IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)

    .def("switch_sfp_soft_tx_control_bit", &timing::GIBV2IONode::switch_sfp_soft_tx_control_bit)

    .def("set_i2c_mux_channels", &timing::GIBV2IONode::set_i2c_mux_channels)

    .def("switch_sfp_tx", &timing::GIBV2IONode::switch_sfp_tx)

    ;


} // NOLINT


} // namespace python

} // namespace timing

} // namespace dunedaq

FIBIONode.hpp

FIBV2IONode.hpp

FMCIONode.hpp

GIBIONode.hpp

GIBV2IONode.hpp

IONode.hpp

MIBIONode.hpp

MIBV2IONode.hpp

PC059IONode.hpp

SIMIONode.hpp

SwitchyardNode.hpp

TLUIONode.hpp

dunedaq::timing::FIBIONode
Class for the FIB board.
Definition FIBIONode.hpp:32

dunedaq::timing::FIBIONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition FIBIONode.cpp:182

dunedaq::timing::FIBIONode::reset
void reset(const std::string &clock_config_file) const override
Reset FIB node.
Definition FIBIONode.cpp:67

dunedaq::timing::FIBIONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition FIBIONode.cpp:162

dunedaq::timing::FIBIONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
reset on-board SFP flags using I2C IO expanders
Definition FIBIONode.cpp:241

dunedaq::timing::FIBIONode::read_active_sfp_mux_channel
uint32_t read_active_sfp_mux_channel() const override
Read the active SFP mux channel.
Definition FIBIONode.cpp:152

dunedaq::timing::FIBIONode::switch_sfp_mux_channel
void switch_sfp_mux_channel(uint32_t mux_channel) const override
Switch the SFP mux channel.
Definition FIBIONode.cpp:141

dunedaq::timing::FIBIONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition FIBIONode.cpp:43

dunedaq::timing::FIBV2IONode
Class for the FIB board.
Definition FIBV2IONode.hpp:35

dunedaq::timing::FIBV2IONode::get_pll_status
std::string get_pll_status(bool print_out=false) const override
Print status of on-board PLL.
Definition FIBV2IONode.cpp:177

dunedaq::timing::FIBV2IONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition FIBV2IONode.cpp:130

dunedaq::timing::FIBV2IONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition FIBV2IONode.cpp:52

dunedaq::timing::FIBV2IONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
Switch on or off the SFP tx laser via the I2C IO expander controlling the sfp tx disable pin....
Definition FIBV2IONode.cpp:142

dunedaq::timing::FIBV2IONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition FIBV2IONode.cpp:111

dunedaq::timing::FIBV2IONode::reset
void reset(const ClockSource &clock_source) const override
Reset IO, with clock file look up.
Definition FIBV2IONode.cpp:69

dunedaq::timing::FIBV2IONode::read_board_temperature
float read_board_temperature() const
Read data from on-board temperature monitor.
Definition FIBV2IONode.cpp:191

dunedaq::timing::FMCIONode
Class for the timing FMC board.
Definition FMCIONode.hpp:33

dunedaq::timing::FMCIONode::get_clock_frequencies_table
std::string get_clock_frequencies_table(bool print_out=false) const override
Print frequencies of on-board clocks.
Definition FMCIONode.cpp:142

dunedaq::timing::FMCIONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition FMCIONode.cpp:45

dunedaq::timing::FMCIONode::reset
void reset(const std::string &clock_config_file) const override
Reset FMC IO.
Definition FMCIONode.cpp:60

dunedaq::timing::FMCIONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP
Definition FMCIONode.cpp:225

dunedaq::timing::GIBIONode
Class for the timing FMC board.
Definition GIBIONode.hpp:33

dunedaq::timing::GIBIONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition GIBIONode.cpp:218

dunedaq::timing::GIBIONode::set_i2c_mux_channels
void set_i2c_mux_channels(uint8_t mux_channel_bitmask) const
Fill hardware monitoring structure.
Definition GIBIONode.cpp:266

dunedaq::timing::GIBIONode::reset
void reset(const std::string &clock_config_file) const override
Reset GIB IO.
Definition GIBIONode.cpp:113

dunedaq::timing::GIBIONode::get_pll
std::unique_ptr< const SI534xSlave > get_pll() const override
GET PLL I2C interface.
Definition GIBIONode.cpp:61

dunedaq::timing::GIBIONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition GIBIONode.cpp:208

dunedaq::timing::GIBIONode::get_hardware_info
std::string get_hardware_info(bool print_out) const override
Print hardware information.
Definition GIBIONode.cpp:71

dunedaq::timing::GIBIONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition GIBIONode.cpp:166

dunedaq::timing::GIBIONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition GIBIONode.cpp:41

dunedaq::timing::GIBV2IONode
Class for the timing FMC board.
Definition GIBV2IONode.hpp:33

dunedaq::timing::IONode::switch_sfp_soft_tx_control_bit
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)
Definition IONode.cpp:337

dunedaq::timing::IONode::get_sfp_status
virtual std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const
Print status of on-board SFP.
Definition IONode.cpp:318

dunedaq::timing::IONode::get_hardware_info
virtual std::string get_hardware_info(bool print_out=false) const
Print hardware information.
Definition IONode.cpp:118

dunedaq::timing::IONode::soft_reset
virtual void soft_reset() const
Reset timing node.
Definition IONode.cpp:296

dunedaq::timing::IONode::get_pll
virtual std::unique_ptr< const SI534xSlave > get_pll() const
Get the PLL chip.
Definition IONode.cpp:230

dunedaq::timing::IONode::read_firmware_frequency
virtual uint32_t read_firmware_frequency() const
Read the word identifying the frequency [units of Hz] of the firmware in the FPGA.
Definition IONode.cpp:78

dunedaq::timing::IONode::get_clock_frequencies_table
virtual std::string get_clock_frequencies_table(bool print_out=false) const
Print frequencies of on-board clocks.
Definition IONode.cpp:263

dunedaq::timing::IONode::get_pll_status
virtual std::string get_pll_status(bool print_out=false) const
Print status of on-board PLL.
Definition IONode.cpp:279

dunedaq::timing::MIBIONode
Class for the timing FMC board.
Definition MIBIONode.hpp:34

dunedaq::timing::MIBIONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition MIBIONode.cpp:196

dunedaq::timing::MIBIONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Switch the SFP mux channel.
Definition MIBIONode.cpp:162

dunedaq::timing::MIBIONode::reset
void reset(const std::string &clock_config_file) const override
Reset MIB IO.
Definition MIBIONode.cpp:77

dunedaq::timing::MIBIONode::switch_sfp_tx
void switch_sfp_tx(uint32_t, bool) const override
control tx laser of on-board SFP
Definition MIBIONode.hpp:117

dunedaq::timing::MIBIONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition MIBIONode.cpp:40

dunedaq::timing::MIBIONode::get_pll_status
std::string get_pll_status(bool print_out=false) const override
Print status of on-board PLL.
Definition MIBIONode.cpp:66

dunedaq::timing::MIBV2IONode
Class for the timing FMC board.
Definition MIBV2IONode.hpp:33

dunedaq::timing::MIBV2IONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition MIBV2IONode.cpp:139

dunedaq::timing::MIBV2IONode::reset
void reset(const std::string &clock_config_file) const override
Reset MIB v2 IO.
Definition MIBV2IONode.cpp:55

dunedaq::timing::MIBV2IONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition MIBV2IONode.cpp:104

dunedaq::timing::MIBV2IONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition MIBV2IONode.cpp:40

dunedaq::timing::MIBV2IONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP
Definition MIBV2IONode.cpp:149

dunedaq::timing::PC059IONode
Class for the PC059 board.
Definition PC059IONode.hpp:34

dunedaq::timing::PC059IONode::read_active_sfp_mux_channel
uint32_t read_active_sfp_mux_channel() const override
Read the active SFP mux channel.
Definition PC059IONode.cpp:134

dunedaq::timing::PC059IONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition PC059IONode.cpp:204

dunedaq::timing::PC059IONode::switch_sfp_mux_channel
void switch_sfp_mux_channel(uint32_t mux_channel) const override
Switch the SFP mux channel.
Definition PC059IONode.cpp:123

dunedaq::timing::PC059IONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition PC059IONode.cpp:161

dunedaq::timing::PC059IONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition PC059IONode.cpp:40

dunedaq::timing::PC059IONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP softly (I2C command)
Definition PC059IONode.cpp:223

dunedaq::timing::PC059IONode::reset
void reset(const std::string &clock_config_file) const override
Reset pc059 node.
Definition PC059IONode.cpp:54

dunedaq::timing::SIMIONode
Class for the timing simulation IO.
Definition SIMIONode.hpp:34

dunedaq::timing::SIMIONode::get_clock_frequencies_table
std::string get_clock_frequencies_table(bool print_out=false) const override
Print frequencies of on-board clocks.
Definition SIMIONode.cpp:149

dunedaq::timing::SIMIONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const override
Control tx laser of on-board SFP softly (I2C command)
Definition SIMIONode.cpp:176

dunedaq::timing::SIMIONode::get_pll_status
std::string get_pll_status(bool print_out=false) const override
Print status of on-board PLL.
Definition SIMIONode.cpp:158

dunedaq::timing::SIMIONode::get_hardware_info
std::string get_hardware_info(bool print_out=false) const override
Print hardware information.
Definition SIMIONode.cpp:73

dunedaq::timing::SIMIONode::reset
void reset(const std::string &clock_config_file) const override
Reset IO.
Definition SIMIONode.cpp:116

dunedaq::timing::SIMIONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition SIMIONode.cpp:167

dunedaq::timing::SIMIONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition SIMIONode.cpp:42

dunedaq::timing::SIMIONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
Control tx laser of on-board SFP softly (I2C command)
Definition SIMIONode.cpp:184

dunedaq::timing::SwitchyardNode::configure_endpoint_source
void configure_endpoint_source(uint8_t endpoint_source, bool dispatch=true) const
Configure endpoint source.
Definition SwitchyardNode.cpp:57

dunedaq::timing::SwitchyardNode::configure_master_source
void configure_master_source(uint8_t master_source, bool dispatch=true) const
Configure master source.
Definition SwitchyardNode.cpp:47

dunedaq::timing::SwitchyardNode::get_status
std::string get_status(bool print_out=false) const override
Print the status of the timing node.
Definition SwitchyardNode.cpp:33

dunedaq::timing::TLUIONode
Class for the TLU board.
Definition TLUIONode.hpp:34

dunedaq::timing::TLUIONode::reset
void reset(const std::string &clock_config_file) const override
Reset IO node.
Definition TLUIONode.cpp:53

dunedaq::timing::TLUIONode::switch_sfp_tx
void switch_sfp_tx(uint32_t, bool) const override
Control tx laser of on-board SFP softly (I2C command)
Definition TLUIONode.cpp:181

dunedaq::timing::TLUIONode::configure_dac
void configure_dac(uint32_t dac_id, uint32_t dac_value, bool internal_ref=false) const
Configure on-board DAC.
Definition TLUIONode.cpp:132

dunedaq::timing::TLUIONode::get_status
std::string get_status(bool print_out=false) const
Print the status of the timing node.
Definition TLUIONode.cpp:39

dunedaq::timing::TLUIONode::switch_sfp_soft_tx_control_bit
void switch_sfp_soft_tx_control_bit(uint32_t, bool) const override
Control tx laser of on-board SFP softly (I2C command)
Definition TLUIONode.cpp:173

dunedaq::timing::TLUIONode::get_sfp_status
std::string get_sfp_status(uint32_t sfp_id, bool print_out=false) const override
Print status of on-board SFP.
Definition TLUIONode.cpp:148

dunedaq::timing::python::register_io
void register_io(py::module &m)
Definition io.cpp:34

dunedaq::timing::ClockSource
ClockSource
Definition definitions.hpp:114

dunedaq
The DUNE-DAQ namespace.
Definition DataStore.hpp:57

timing
Definition __init__.py:1