DUNE-DAQ
DUNE Trigger and Data Acquisition software
Loading...
Searching...
No Matches
Functions
dunedaq::timing::python Namespace Reference

Functions

std::map< std::string, FixedLengthCommandType > swap_commands_map (const std::map< FixedLengthCommandType, std::string > &command_map)
void register_definitions (py::module &m)
void register_endpoint (py::module &m)
void register_i2c (py::module &m)
void register_io (py::module &m)
void register_master (py::module &m)
void register_top_designs (py::module &)
void register_toolbox (py::module &)
 PYBIND11_MODULE (_daq_timing_py, top_module)

Function Documentation

◆ PYBIND11_MODULE()

dunedaq::timing::python::PYBIND11_MODULE ( _daq_timing_py ,
top_module  )

Definition at line 26 of file timing_wrapper.cpp.

26 {
27
28 top_module.doc() = "c++ implementation of timing python modules"; // optional module docstring
29
30 // timing.core
31 py::module_ core_module = top_module.def_submodule("core");
32
33 timing::python::register_i2c(core_module);
34 timing::python::register_endpoint(core_module);
35 timing::python::register_io(core_module);
36 timing::python::register_master(core_module);
37 timing::python::register_top_designs(core_module);
38
39 // timing.common
40 py::module_ common_module = top_module.def_submodule("common");
41
42 // timing.common.definitions
43 py::module_ defs_module = common_module.def_submodule("definitions");
44 timing::python::register_definitions(defs_module);
45
46 // timing.common.toolbox
47 py::module_ toolbox_module = common_module.def_submodule("toolbox");
48 timing::python::register_toolbox(toolbox_module);
49}
dunedaq::timing::python::register_top_designs
void register_top_designs(py::module &)
Definition top_designs.cpp:29
dunedaq::timing::python::register_definitions
void register_definitions(py::module &m)
Definition definitions.cpp:38
dunedaq::timing::python::register_toolbox
void register_toolbox(py::module &)
Definition toolbox.cpp:21
dunedaq::timing::python::register_io
void register_io(py::module &m)
Definition io.cpp:35
dunedaq::timing::python::register_endpoint
void register_endpoint(py::module &m)
Definition endpoint.cpp:22
dunedaq::timing::python::register_i2c
void register_i2c(py::module &m)
Definition i2c.cpp:31
dunedaq::timing::python::register_master
void register_master(py::module &m)
Definition master.cpp:23

◆ register_definitions()

void dunedaq::timing::python::register_definitions ( py::module & m)

Definition at line 38 of file definitions.cpp.

39{
40 py::enum_<BoardType>(m, "BoardType")
41 .value("kBoardFMC", kBoardFMC)
42 .value("kBoardSim", kBoardSim)
43 .value("kBoardPC059", kBoardPC059)
44 .value("kBoardMicrozed", kBoardMicrozed)
45 .value("kBoardTLU", kBoardTLU)
46 .value("kBoardFIB", kBoardFIB)
47 .value("kBoardMIB", kBoardMIB)
48 .value("kBoardPC069", kBoardPC069)
49 .value("kBoardGIB", kBoardGIB)
50 .value("kBoardGIBV3", kBoardGIBV3)
51 .value("kBoardUnknown", kBoardUnknown)
52 .export_values();
53
54 py::enum_<BoardRevision>(m, "BoardRevision")
55 .value("kFMCRev1", kFMCRev1)
56 .value("kFMCRev2", kFMCRev2)
57 .value("kFMCRev3", kFMCRev3)
58 .value("kFMCRev4", kFMCRev4)
59 .value("kPC059Rev1", kPC059Rev1)
60 .value("kTLURev1", kTLURev1)
61 .value("kSIMRev1", kSIMRev1)
62 .value("kFIBRev1", kFIBRev1)
63 .value("kMIBRev1", kMIBRev1)
64 .value("kPC069a", kPC069a)
65 .value("kPC069b", kPC069b)
66 .value("kPC069c", kPC069c)
67 .value("kMIBRev2", kMIBRev2)
68 .value("kGIBRev1", kGIBRev1)
69 .value("kFIBRev2", kFIBRev2)
70 .export_values();
71
72 py::enum_<CarrierType>(m, "CarrierType")
73 .value("kCarrierEnclustraA35", kCarrierEnclustraA35)
74 .value("kCarrierKC705", kCarrierKC705)
75 .value("kCarrierMicrozed", kCarrierMicrozed)
76 .value("kCarrierATFC", kCarrierATFC)
77 .value("kCarrierAFC", kCarrierAFC)
78 .value("kCarrierNexusVideo", kCarrierNexusVideo)
79 .value("kCarrierTrenzTE0712", kCarrierTrenzTE0712)
80 .value("kCarrierUnknown", kCarrierUnknown)
81 .export_values();
82
83 py::enum_<DesignType>(m, "DesignType")
84 .value("kDesignMaster", kDesignMaster)
85 .value("kDesignOuroborosSim", kDesignOuroborosSim)
86 .value("kDesignOuroboros", kDesignOuroboros)
87 .value("kDesignTest", kDesignTest)
88 .value("kDesignEndpoint", kDesignEndpoint)
89 .value("kDesignFanout", kDesignFanout)
90 .value("kDesignOverlord", kDesignOverlord)
91 .value("kDesignEndpoBICRT", kDesignEndpoBICRT)
92 .value("kDesignChronos", kDesignChronos)
93 .value("kDesignBoreas", kDesignBoreas)
94 .value("kDesignKerberos", kDesignKerberos)
95 .value("kDesignGaia", kDesignGaia)
96 .value("kDesignCharon", kDesignCharon)
97 .value("kDesignHades", kDesignHades)
98 .value("kDesignUnknown", kDesignUnknown)
99 .export_values();
100
101 py::enum_<FixedLengthCommandType>(m, "FixedLengthCommandType")
102 .value("TimeSync", TimeSync)
103 .value("Echo", Echo)
104 .value("SpillStart", SpillStart)
105 .value("SpillStop", SpillStop)
106 .value("RunStart", RunStart)
107 .value("RunStop", RunStop)
108 .value("WibCalib", WibCalib)
109 .value("SSPCalib", SSPCalib)
110 .value("FakeTrig0", FakeTrig0)
111 .value("FakeTrig1", FakeTrig1)
112 .value("FakeTrig2", FakeTrig2)
113 .value("FakeTrig3", FakeTrig3)
114 .value("BeamTrig", BeamTrig)
115 .value("NoBeamTrig", NoBeamTrig)
116 .value("ExtFakeTrig", ExtFakeTrig)
117 .export_values();
118
119 py::enum_<ClockSource>(m, "ClockSource")
120 .value("kFreeRun", kFreeRun)
121 .value("kInput0", kInput0)
122 .value("kInput1", kInput1)
123 .value("kInput2", kInput2)
124 .value("kInput3", kInput3)
125 .export_values();
126
127 py::enum_<TimestampSource>(m, "TimestampSource")
128 .value("kUpstream", kUpstream)
129 .value("kSoftware", kSoftware)
130 .value("kMixed", kMixed)
131 .export_values();
132
133 py::enum_<TimestampEpoch>(m, "TimestampEpoch")
134 .value("kUNIX", kUNIX)
135 .value("kCustom", kCustom)
136 .export_values();
137
138 py::enum_<TimestampTimebase>(m, "TimestampTimebase")
139 .value("kTAI", kTAI)
140 .value("kUTC", kUTC)
141 .export_values();
142
143 m.attr("kBoardNameMap") = timing::IONode::get_board_type_map();
144 m.attr("kCarrierNameMap") = timing::IONode::get_carrier_type_map();
145 m.attr("kDesignNameMap") = timing::IONode::get_design_type_map();
146 m.attr("kBoardRevisionMap") = timing::IONode::get_board_revision_map();
147 m.attr("kUIDRevisionMap") = timing::IONode::get_board_uid_revision_map();
148 m.attr("kClockConfigMap") = timing::IONode::get_clock_config_map();
149 m.attr("kEpStates") = EndpointNode::get_endpoint_state_map();
150 m.attr("kLibrarySupportedBoards") = timing::IONode::get_library_supported_boards();
151 m.attr("kLibrarySupportedDesigns") = timing::IONode::get_library_supported_designs();
152 m.attr("kMasterFWMajorRequired") = MasterNode::required_major_firmware_version;
153 m.attr("kHSIWordsNumber") = HSINode::hsi_buffer_event_words_number;
154}
dunedaq::timing::EndpointNode::get_endpoint_state_map
static std::map< uint8_t, std::string > get_endpoint_state_map()
Get the states map.
Definition EndpointNode.hpp:91
dunedaq::timing::HSINode::hsi_buffer_event_words_number
static constexpr size_t hsi_buffer_event_words_number
Definition HSINode.hpp:133
dunedaq::timing::IONode::get_library_supported_boards
static const std::vector< BoardType > & get_library_supported_boards()
Definition IONode.hpp:211
dunedaq::timing::IONode::get_clock_config_map
static const std::map< std::string, std::string > & get_clock_config_map()
Definition IONode.hpp:210
dunedaq::timing::IONode::get_library_supported_designs
static const std::vector< DesignType > & get_library_supported_designs()
Definition IONode.hpp:212
dunedaq::timing::IONode::get_board_uid_revision_map
static const std::map< uint64_t, BoardRevision > & get_board_uid_revision_map()
Definition IONode.hpp:208
dunedaq::timing::IONode::get_design_type_map
static const std::map< DesignType, std::string > & get_design_type_map()
Definition IONode.hpp:209
dunedaq::timing::IONode::get_board_revision_map
static const std::map< BoardRevision, std::string > & get_board_revision_map()
Definition IONode.hpp:207
dunedaq::timing::IONode::get_board_type_map
static const std::map< BoardType, std::string > & get_board_type_map()
Definition IONode.hpp:203
dunedaq::timing::IONode::get_carrier_type_map
static const std::map< CarrierType, std::string > & get_carrier_type_map()
Definition IONode.hpp:205
dunedaq::timing::MasterNode::required_major_firmware_version
static const uint32_t required_major_firmware_version
Definition MasterNode.hpp:168

◆ register_endpoint()

void dunedaq::timing::python::register_endpoint ( py::module & m)

Definition at line 22 of file endpoint.cpp.

23{
24
25 py::class_<timing::HSINode, uhal::Node>(m, "HSINode")
26 .def(py::init<const uhal::Node&>())
27 .def("get_status", &timing::HSINode::get_status, py::arg("print_out") = false)
28 .def("configure_hsi",
29 &timing::HSINode::configure_hsi,
30 py::arg("src"),
31 py::arg("re_mask"),
32 py::arg("fe_mask"),
33 py::arg("inv_mask"),
34 py::arg("rate"),
35 py::arg("clock_frequency_hz"),
36 py::arg("dispatch") = true)
37 .def("start_hsi", &timing::HSINode::start_hsi, py::arg("dispatch") = true)
38 .def("stop_hsi", &timing::HSINode::stop_hsi, py::arg("dispatch") = true)
39 .def("reset_hsi", &timing::HSINode::reset_hsi, py::arg("dispatch") = true)
40 .def("get_data_buffer_table",
41 &timing::HSINode::get_data_buffer_table,
42 py::arg("read_all") = false,
43 py::arg("print_out") = false)
44 .def("read_buffer_warning", &timing::HSINode::read_buffer_warning)
45 .def("read_buffer_error", &timing::HSINode::read_buffer_error)
46 .def<uhal::ValVector<uint32_t> (timing::HSINode::*)(uint16_t&, bool, bool) const>("read_data_buffer", &timing::HSINode::read_data_buffer);
47
48 py::class_<timing::EndpointNode, uhal::Node>(m, "EndpointNode")
49 .def(py::init<const uhal::Node&>())
50 .def("disable", &timing::EndpointNode::disable)
51 .def("enable", &timing::EndpointNode::enable, py::arg("address") = 0, py::arg("partition") = 0)
52 .def("reset", &timing::EndpointNode::reset, py::arg("address") = 0, py::arg("partition") = 0)
53 .def("get_status", &timing::EndpointNode::get_status, py::arg("print_out") = false);
54}
dunedaq::timing::EndpointNode::enable
void enable(uint32_t address=0, uint32_t partition=0) const override
Enable the endpoint.
Definition EndpointNode.cpp:35
dunedaq::timing::EndpointNode::reset
void reset(uint32_t address=0, uint32_t partition=0) const override
Reset the endpoint.
Definition EndpointNode.cpp:83
dunedaq::timing::EndpointNode::disable
void disable() const override
Disable the endpoint.
Definition EndpointNode.cpp:73
dunedaq::timing::EndpointNode::get_status
std::string get_status(bool print_out=false) const override
Print the status of the timing node.
Definition EndpointNode.cpp:99
dunedaq::timing::HSINode
Class for HSI nodes.
Definition HSINode.hpp:37
dunedaq::timing::HSINode::read_buffer_warning
bool read_buffer_warning() const
Read butffer warning flag.
Definition HSINode.cpp:267
dunedaq::timing::HSINode::get_status
std::string get_status(bool print_out=false) const override
Print the status of the timing node.
Definition HSINode.cpp:36
dunedaq::timing::HSINode::stop_hsi
void stop_hsi(bool dispatch=true) const
Stop HSI triggering.
Definition HSINode.cpp:238
dunedaq::timing::HSINode::read_buffer_error
bool read_buffer_error() const
Read butffer error flag.
Definition HSINode.cpp:277
dunedaq::timing::HSINode::configure_hsi
void configure_hsi(uint32_t src, uint32_t re_mask, uint32_t fe_mask, uint32_t inv_mask, double rate, uint32_t clock_frequency_hz, bool dispatch=true) const
Configure HSI triggering.
Definition HSINode.cpp:174
dunedaq::timing::HSINode::read_data_buffer
uhal::ValVector< uint32_t > read_data_buffer(uint16_t &n_words, bool read_all=false, bool fail_on_error=false) const
Read the contents of the endpoint data buffer.
Definition HSINode.cpp:90
dunedaq::timing::HSINode::start_hsi
void start_hsi(bool dispatch=true) const
Start HSI triggering.
Definition HSINode.cpp:228
dunedaq::timing::HSINode::get_data_buffer_table
std::string get_data_buffer_table(bool read_all=false, bool print_out=false) const
Print the contents of the endpoint data buffer.
Definition HSINode.cpp:150
dunedaq::timing::HSINode::reset_hsi
void reset_hsi(bool dispatch=true) const
Reset HSI.
Definition HSINode.cpp:248
dunedaq::bool
Unknown serialization type<< t,((char) t)) template< typename T > inline std::string datatype_to_string() { return "Unknown";} namespace serialization { template< typename T > struct is_serializable :std::false_type {};enum SerializationType { kMsgPack };inline SerializationType from_string(const std::string s) { if(s=="msgpack") return kMsgPack;throw UnknownSerializationTypeString(ERS_HERE, s);} constexpr uint8_t serialization_type_byte(SerializationType stype) { switch(stype) { case kMsgPack:return 'M';default:throw UnknownSerializationTypeEnum(ERS_HERE);} } constexpr SerializationType DEFAULT_SERIALIZATION_TYPE=kMsgPack;template< class T > std::vector< uint8_t > serialize(const T &obj, SerializationType stype=DEFAULT_SERIALIZATION_TYPE) { switch(stype) { case kMsgPack:{ msgpack::sbuffer buf;msgpack::pack(buf, obj);std::vector< uint8_t > ret(buf.size()+1);ret[0]=serialization_type_byte(stype);std::copy(buf.data(), buf.data()+buf.size(), ret.begin()+1);return ret;} default:throw UnknownSerializationTypeEnum(ERS_HERE);} } template< class T, typename CharType=unsigned char > T deserialize(const std::vector< CharType > &v) { switch(v[0]) { case serialization_type_byte(kMsgPack):{ try { msgpack::object_handle oh=msgpack::unpack(const_cast< char * >(reinterpret_cast< const char * >(v.data()+1)), v.size() - 1,[](msgpack::type::object_type, std::size_t, void *) -> bool
Definition Serialization.hpp:256

◆ register_i2c()

void dunedaq::timing::python::register_i2c ( py::module & m)

Definition at line 31 of file i2c.cpp.

32{
33 // .def("hardReset", (void ( mp7::CtrlNode::*) (double)) 0, mp7_CTRLNODE_hardReset_overloads())
34
35 // Wrap timing::I2CMasterNode
36 py::class_<timing::I2CMasterNode, uhal::Node>(m, "I2CMasterNode")
37 .def(py::init<const uhal::Node&>())
38 .def("get_i2c_clock_prescale", &timing::I2CMasterNode::get_i2c_clock_prescale)
39 .def("read_i2c",
40 &timing::I2CMasterNode::read_i2c,
41 py::arg("i2c_device_address"),
42 py::arg("i2c_reg_address"),
43 py::arg("atomic") = false
44 )
45 .def("write_i2c",
46 &timing::I2CMasterNode::write_i2c,
47 py::arg("i2c_device_address"),
48 py::arg("i2c_reg_address"),
49 py::arg("data"),
50 py::arg("send_stop") = true)
51 .def("read_i2cArray",
52 &timing::I2CMasterNode::read_i2cArray,
53 py::arg("i2c_device_address"),
54 py::arg("i2c_reg_address"),
55 py::arg("number_of_words"),
56 py::arg("atomic") = false
57 )
58 .def("write_i2cArray",
59 &timing::I2CMasterNode::write_i2cArray,
60 py::arg("i2c_device_address"),
61 py::arg("i2c_reg_address"),
62 py::arg("data"),
63 py::arg("send_stop") = true)
64 .def("read_i2cPrimitive", &timing::I2CMasterNode::read_i2cPrimitive)
65 .def("write_i2cPrimitive",
66 &timing::I2CMasterNode::write_i2cPrimitive,
67 py::arg("i2c_device_address"),
68 py::arg("data"),
69 py::arg("send_stop") = true)
70 .def("get_slaves", &timing::I2CMasterNode::get_slaves)
71 .def("get_slave", &timing::I2CMasterNode::get_slave, py::return_value_policy::reference_internal)
72 .def("get_slave_address", &timing::I2CMasterNode::get_slave_address)
73 .def("ping", &timing::I2CMasterNode::ping)
74 .def("scan", &timing::I2CMasterNode::scan)
75 .def("reset", &timing::I2CMasterNode::reset);
76
77 // Wrap timing::I2CSlave
78 py::class_<timing::I2CSlave>(m, "I2CSlave")
79 .def("get_i2c_address", &timing::I2CSlave::get_i2c_address)
80 .def<uint8_t (timing::I2CSlave::*)(uint32_t) const>("read_i2c", // NOLINT(build/unsigned)
81 &timing::I2CSlave::read_i2c)
82 .def<uint8_t (timing::I2CSlave::*)(uint32_t, uint32_t) const>("read_i2c", // NOLINT(build/unsigned)
83 &timing::I2CSlave::read_i2c)
84 .def<uint8_t (timing::I2CSlave::*)(uint32_t) const>("read_i2c_atomic", // NOLINT(build/unsigned)
85 &timing::I2CSlave::read_i2c_atomic)
86 .def<uint8_t (timing::I2CSlave::*)(uint32_t, uint32_t) const>("read_i2c_atomic", // NOLINT(build/unsigned)
87 &timing::I2CSlave::read_i2c_atomic)
88 .def<void (timing::I2CSlave::*)(uint32_t, uint8_t, bool) const>("write_i2c", // NOLINT(build/unsigned)
89 &timing::I2CSlave::write_i2c,
90 py::arg("i2c_reg_address"),
91 py::arg("data"),
92 py::arg("send_stop") = true)
93 .def<void (timing::I2CSlave::*)(uint32_t, uint32_t, uint8_t, bool) const>("write_i2c", // NOLINT(build/unsigned)
94 &timing::I2CSlave::write_i2c,
95 py::arg("i2c_device_address"),
96 py::arg("i2c_reg_address"),
97 py::arg("data"),
98 py::arg("send_stop") = true)
99 .def<std::vector<uint8_t> (timing::I2CSlave::*)(uint32_t, uint32_t) const>( // NOLINT(build/unsigned)
100 "read_i2cArray",
101 &timing::I2CSlave::read_i2cArray)
102 .def<std::vector<uint8_t> (timing::I2CSlave::*)(uint32_t, uint32_t, uint32_t) const>( // NOLINT(build/unsigned)
103 "read_i2cArray",
104 &timing::I2CSlave::read_i2cArray)
105 .def<std::vector<uint8_t> (timing::I2CSlave::*)(uint32_t, uint32_t) const>( // NOLINT(build/unsigned)
106 "read_i2cArray_atomic",
107 &timing::I2CSlave::read_i2cArray_atomic)
108 .def<std::vector<uint8_t> (timing::I2CSlave::*)(uint32_t, uint32_t, uint32_t) const>( // NOLINT(build/unsigned)
109 "read_i2cArray_atomic",
110 &timing::I2CSlave::read_i2cArray_atomic)
111 .def<void (timing::I2CSlave::*)(uint32_t, std::vector<uint8_t>, bool) const>( // NOLINT(build/unsigned)
112 "write_i2cArray",
113 &timing::I2CSlave::write_i2cArray,
114 py::arg("i2c_reg_address"),
115 py::arg("data"),
116 py::arg("send_stop") = true)
117 .def<void (timing::I2CSlave::*)(uint32_t, uint32_t, std::vector<uint8_t>, bool) const>( // NOLINT(build/unsigned)
118 "write_i2cArray",
119 &timing::I2CSlave::write_i2cArray,
120 py::arg("i2c_device_address"),
121 py::arg("i2c_reg_address"),
122 py::arg("data"),
123 py::arg("send_stop") = true)
124 .def("read_i2cPrimitive", &timing::I2CSlave::read_i2cPrimitive)
125 .def("write_i2cPrimitive", &timing::I2CSlave::write_i2cPrimitive, py::arg("data"), py::arg("send_stop") = true)
126 .def("ping", &timing::I2CSlave::ping);
127
128 // Wrap SIChipSlave
129 py::class_<timing::SIChipSlave, timing::I2CSlave>(m, "SIChipSlave")
130 .def(py::init<const timing::I2CMasterNode*, uint8_t>()) // NOLINT(build/unsigned)
131 .def("read_page", &timing::SIChipSlave::read_page)
132 .def("switch_page", &timing::SIChipSlave::switch_page)
133 .def("read_device_version", &timing::SIChipSlave::read_device_version)
134 .def("read_clock_register", &timing::SIChipSlave::read_clock_register)
135 .def("write_clock_register", &timing::SIChipSlave::write_clock_register);
136
137 // Wrap SI534xSlave
138 py::class_<timing::SI534xSlave, timing::SIChipSlave>(m, "SI534xSlave")
139 .def(py::init<const timing::I2CMasterNode*, uint8_t>()) // NOLINT(build/unsigned)
140 .def("configure", &timing::SI534xSlave::configure)
141 .def("read_config_id", &timing::SI534xSlave::read_config_id)
142 .def("get_status", &timing::SI534xSlave::get_status, py::arg("print_out"))
143 // .def("registers", &timing::SI534xSlave::registers)
144 ;
145
146 // Wrap SI534xNode
147 py::class_<timing::SI534xNode, timing::SI534xSlave, timing::I2CMasterNode>(m, "SI534xNode")
148 .def(py::init<const uhal::Node&>());
149
150 // Wrap I2CExpanderSlave
151 py::class_<timing::I2CExpanderSlave, timing::I2CSlave>(m, "I2CExpanderSlave")
152 .def(py::init<const timing::I2CMasterNode*, uint8_t>()) // NOLINT(build/unsigned)
153 .def("set_io", &timing::I2CExpanderSlave::set_io)
154 .def("set_inversion", &timing::I2CExpanderSlave::set_inversion)
155 .def("set_outputs", &timing::I2CExpanderSlave::set_outputs)
156 .def("read_inputs", &timing::I2CExpanderSlave::read_inputs)
157 .def("read_outputs_config", &timing::I2CExpanderSlave::read_outputs_config)
158 .def("debug", &timing::I2CExpanderSlave::debug);
159
160// // Wrap I2CExpanderNode
161// py::class_<timing::I2CExpanderNode, timing::I2CExpanderSlave, timing::I2CMasterNode>(m, "I2CExpanderNode")
162// .def(py::init<const uhal::Node&>());
163
164 // Wrap DACSlave
165 py::class_<timing::DACSlave, timing::I2CSlave>(m, "DACSlave")
166 .def(py::init<const timing::I2CMasterNode*, uint8_t>()) // NOLINT(build/unsigned)
167 .def("set_interal_ref", &timing::DACSlave::set_interal_ref)
168 .def("set_dac", &timing::DACSlave::set_dac);
169
170 // Wrap DACNode
171 py::class_<timing::DACNode, timing::DACSlave, timing::I2CMasterNode>(m, "DACNode").def(py::init<const uhal::Node&>());
172 // NOLINT(readability/fn_size)
173
174 py::class_<timing::LTC2945Node, timing::I2CSlave>(m, "LTC2945Node")
175 .def(py::init<const timing::I2CMasterNode*, uint8_t, double>()) // NOLINT(build/unsigned)
176 .def("read_v_in", &timing::LTC2945Node::read_v_in)
177 .def("read_delta_sense_v", &timing::LTC2945Node::read_delta_sense_v)
178 .def("read_power", &timing::LTC2945Node::read_power)
179 ;
180
181 // Wrap I2C9546SwitchNode
182 py::class_<timing::I2C9546SwitchSlave, timing::I2CSlave>(m, "I2C9546SwitchSlave")
183 .def(py::init<const timing::I2CMasterNode*, uint8_t>()) // NOLINT(build/unsigned)
184 .def("enable_channel", &timing::I2C9546SwitchSlave::enable_channel)
185 .def("disable_channel", &timing::I2C9546SwitchSlave::disable_channel)
186 .def("read_channels_states", &timing::I2C9546SwitchSlave::read_channels_states)
187 .def("set_channels_states", &timing::I2C9546SwitchSlave::set_channels_states);
188}
dunedaq::timing::DACSlave::set_interal_ref
void set_interal_ref(bool internal_ref) const
Use DAC internal reference.
Definition DACNode.cpp:25
dunedaq::timing::DACSlave::set_dac
void set_dac(uint8_t channel, uint32_t code) const
Configure DAC channel.
Definition DACNode.cpp:33
dunedaq::timing::I2CMasterNode::get_i2c_clock_prescale
virtual uint16_t get_i2c_clock_prescale() const
Definition I2CMasterNode.hpp:49
dunedaq::timing::I2CMasterNode::write_i2c
virtual void write_i2c(uint8_t i2c_device_address, uint32_t i2c_reg_address, uint8_t data, bool send_stop=true) const
Definition I2CMasterNode.cpp:159
dunedaq::timing::I2CMasterNode::scan
std::vector< uint8_t > scan() const
Definition I2CMasterNode.cpp:329
dunedaq::timing::I2CMasterNode::write_i2cPrimitive
virtual void write_i2cPrimitive(uint8_t i2c_device_address, const std::vector< uint8_t > &data, bool send_stop=true) const
Definition I2CMasterNode.cpp:221
dunedaq::timing::I2CMasterNode::read_i2c
virtual uint8_t read_i2c(uint8_t i2c_device_address, uint32_t i2c_reg_address, bool atomic=false) const
commodity functions
Definition I2CMasterNode.cpp:146
dunedaq::timing::I2CMasterNode::ping
bool ping(uint8_t i2c_device_address, bool throw_excp=false) const
Definition I2CMasterNode.cpp:309
dunedaq::timing::I2CMasterNode::get_slave_address
virtual uint8_t get_slave_address(const std::string &name) const
Definition I2CMasterNode.cpp:121
dunedaq::timing::I2CMasterNode::read_i2cPrimitive
virtual std::vector< uint8_t > read_i2cPrimitive(uint8_t i2c_device_address, uint32_t number_of_bytes) const
Definition I2CMasterNode.cpp:213
dunedaq::timing::I2CMasterNode::get_slaves
virtual std::vector< std::string > get_slaves() const
Definition I2CMasterNode.cpp:110
dunedaq::timing::I2CMasterNode::write_i2cArray
virtual void write_i2cArray(uint8_t i2c_device_address, uint32_t i2c_reg_address, std::vector< uint8_t > data, bool send_stop=true) const
Definition I2CMasterNode.cpp:194
dunedaq::timing::I2CMasterNode::get_slave
virtual const I2CSlave & get_slave(const std::string &name) const
Definition I2CMasterNode.cpp:134
dunedaq::timing::I2CMasterNode::read_i2cArray
virtual std::vector< uint8_t > read_i2cArray(uint8_t i2c_device_address, uint32_t i2c_reg_address, uint32_t number_of_words, bool atomic=false) const
Definition I2CMasterNode.cpp:175
dunedaq::timing::I2CSlave::get_i2c_address
uint8_t get_i2c_address() const
Definition I2CSlave.hpp:47
dunedaq::timing::I2CSlave::write_i2cArray
void write_i2cArray(uint32_t i2c_device_address, uint32_t i2c_reg_address, std::vector< uint8_t > data, bool send_stop=true) const
Definition I2CSlave.cpp:133
dunedaq::timing::I2CSlave::read_i2c
uint8_t read_i2c(uint32_t i2c_device_address, uint32_t i2c_reg_address) const
comodity functions
Definition I2CSlave.cpp:46
dunedaq::timing::I2CSlave::read_i2c_atomic
uint8_t read_i2c_atomic(uint32_t i2c_device_address, uint32_t i2c_reg_address) const
Definition I2CSlave.cpp:62
dunedaq::timing::I2CSlave::read_i2cPrimitive
std::vector< uint8_t > read_i2cPrimitive(uint32_t number_of_bytes) const
Definition I2CSlave.cpp:155
dunedaq::timing::I2CSlave::read_i2cArray
std::vector< uint8_t > read_i2cArray(uint32_t i2c_device_address, uint32_t i2c_reg_address, uint32_t number_of_words) const
Definition I2CSlave.cpp:97
dunedaq::timing::I2CSlave::write_i2cPrimitive
void write_i2cPrimitive(const std::vector< uint8_t > &data, bool send_stop=true) const
Definition I2CSlave.cpp:163
dunedaq::timing::I2CSlave::ping
bool ping(bool throw_excp=false) const
Definition I2CSlave.cpp:171
dunedaq::timing::I2CSlave::write_i2c
void write_i2c(uint32_t i2c_device_address, uint32_t i2c_reg_address, uint8_t data, bool send_stop=true) const
Definition I2CSlave.cpp:78
dunedaq::timing::I2CSlave::read_i2cArray_atomic
std::vector< uint8_t > read_i2cArray_atomic(uint32_t i2c_reg_address, uint32_t number_of_words) const
Definition I2CSlave.cpp:125
dunedaq::timing::LTC2945Node::read_power
double read_power() const
Read power [W].
Definition LTC2945Node.cpp:100
dunedaq::timing::LTC2945Node::read_v_in
double read_v_in() const
Read V in [V].
Definition LTC2945Node.cpp:68
dunedaq::timing::LTC2945Node::read_delta_sense_v
double read_delta_sense_v() const
Read delta sense voltage [V].
Definition LTC2945Node.cpp:84
dunedaq::timing::SIChipSlave::switch_page
void switch_page(uint8_t page) const
{ function_description }
Definition SIChipSlave.cpp:47
dunedaq::timing::SIChipSlave::write_clock_register
void write_clock_register(uint16_t address, uint8_t data) const
Writes a clock register.
Definition SIChipSlave.cpp:97
dunedaq::timing::SIChipSlave::read_page
uint8_t read_page() const
Reads the current page.
Definition SIChipSlave.cpp:35
dunedaq::timing::SIChipSlave::read_clock_register
uint8_t read_clock_register(uint16_t address) const
Reads a clock register.
Definition SIChipSlave.cpp:73
dunedaq::timing::SIChipSlave::read_device_version
uint32_t read_device_version() const
Reads a device version.
Definition SIChipSlave.cpp:59

◆ register_io()

void dunedaq::timing::python::register_io ( py::module & m)

Definition at line 35 of file io.cpp.

36{
37
38 py::class_<timing::IONode, uhal::Node>(m, "IONode");
39
40 py::class_<timing::FMCIONode, timing::IONode, uhal::Node>(m, "FMCIONode")
41 .def(py::init<const uhal::Node&>())
42 .def<void (timing::FMCIONode::*)(const std::string&) const>(
43 "reset", &timing::FMCIONode::reset, py::arg("clock_config_file"))
44 .def<void (timing::FMCIONode::*)(const timing::ClockSource&) const>(
45 "reset", &timing::FMCIONode::reset, py::arg("clock_source"))
46 .def("soft_reset", &timing::FMCIONode::soft_reset)
47 .def("read_firmware_frequency", &timing::FMCIONode::read_firmware_frequency)
48 .def("get_clock_frequencies_table", &timing::FMCIONode::get_clock_frequencies_table, py::arg("print_out") = false)
49 .def("get_status", &timing::FMCIONode::get_status, py::arg("print_out") = false)
50 .def("get_pll_status", &timing::FMCIONode::get_pll_status, py::arg("print_out") = false)
51 .def("get_hardware_info", &timing::FMCIONode::get_hardware_info, py::arg("print_out") = false)
52 .def("get_sfp_status", &timing::FMCIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
53 .def("switch_sfp_soft_tx_control_bit", &timing::FMCIONode::switch_sfp_soft_tx_control_bit)
54 .def("switch_sfp_tx", &timing::FMCIONode::switch_sfp_tx);
55
56 py::class_<timing::PC059IONode, timing::IONode, uhal::Node>(m, "PC059IONode")
57 .def(py::init<const uhal::Node&>())
58 .def<void (timing::PC059IONode::*)(const std::string&) const>(
59 "reset", &timing::PC059IONode::reset, py::arg("clock_config_file"))
60 .def<void (timing::PC059IONode::*)(const timing::ClockSource&) const>(
61 "reset", &timing::PC059IONode::reset, py::arg("clock_source"))
62 .def("soft_reset", &timing::PC059IONode::soft_reset)
63 .def("read_firmware_frequency", &timing::PC059IONode::read_firmware_frequency)
64 .def("get_clock_frequencies_table", &timing::PC059IONode::get_clock_frequencies_table, py::arg("print_out") = false)
65 .def("get_status", &timing::PC059IONode::get_status, py::arg("print_out") = false)
66 .def("get_pll_status", &timing::PC059IONode::get_pll_status, py::arg("print_out") = false)
67 .def("get_hardware_info", &timing::PC059IONode::get_hardware_info, py::arg("print_out") = false)
68 .def("get_sfp_status", &timing::PC059IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
69 .def("switch_sfp_soft_tx_control_bit", &timing::PC059IONode::switch_sfp_soft_tx_control_bit)
70 .def("switch_sfp_mux_channel", &timing::PC059IONode::switch_sfp_mux_channel, py::arg("mux_channel"))
71 .def("read_active_sfp_mux_channel", &timing::PC059IONode::read_active_sfp_mux_channel)
72 .def("switch_sfp_tx", &timing::PC059IONode::switch_sfp_tx);
73
74 py::class_<timing::FIBIONode, timing::IONode, uhal::Node>(m, "FIBIONode")
75 .def(py::init<const uhal::Node&>())
76 .def<void (timing::FIBIONode::*)(const std::string&) const>(
77 "reset", &timing::FIBIONode::reset, py::arg("clock_config_file"))
78 .def<void (timing::FIBIONode::*)(const timing::ClockSource&) const>(
79 "reset", &timing::FIBIONode::reset, py::arg("clock_source"))
80 .def("soft_reset", &timing::FIBIONode::soft_reset)
81 .def("read_firmware_frequency", &timing::FIBIONode::read_firmware_frequency)
82 .def("get_clock_frequencies_table", &timing::FIBIONode::get_clock_frequencies_table, py::arg("print_out") = false)
83 .def("get_status", &timing::FIBIONode::get_status, py::arg("print_out") = false)
84 .def("get_pll_status", &timing::FIBIONode::get_pll_status, py::arg("print_out") = false)
85 .def("get_hardware_info", &timing::FIBIONode::get_hardware_info, py::arg("print_out") = false)
86 .def("get_sfp_status", &timing::FIBIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
87 .def("switch_sfp_soft_tx_control_bit", &timing::FIBIONode::switch_sfp_soft_tx_control_bit)
88 .def("switch_sfp_mux_channel", &timing::FIBIONode::switch_sfp_mux_channel, py::arg("mux_channel"))
89 .def("read_active_sfp_mux_channel", &timing::FIBIONode::read_active_sfp_mux_channel)
90 .def("switch_sfp_tx", &timing::FIBIONode::switch_sfp_tx);
91
92 py::class_<timing::FIBV2IONode, timing::IONode, uhal::Node>(m, "FIBV2IONode")
93 .def(py::init<const uhal::Node&>())
94 .def<void (timing::FIBV2IONode::*)(const timing::ClockSource&) const>(
95 "reset", &timing::FIBV2IONode::reset, py::arg("clock_source"))
96 .def("soft_reset", &timing::FIBV2IONode::soft_reset)
97 .def("read_firmware_frequency", &timing::FIBV2IONode::read_firmware_frequency)
98 .def("get_clock_frequencies_table", &timing::FIBV2IONode::get_clock_frequencies_table, py::arg("print_out") = false)
99 .def("get_status", &timing::FIBV2IONode::get_status, py::arg("print_out") = false)
100 .def("get_pll_status", &timing::FIBV2IONode::get_pll_status, py::arg("print_out") = false)
101 .def("get_hardware_info", &timing::FIBV2IONode::get_hardware_info, py::arg("print_out") = false)
102 .def("get_sfp_status", &timing::FIBV2IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
103 .def("switch_sfp_soft_tx_control_bit", &timing::FIBV2IONode::switch_sfp_soft_tx_control_bit)
104 .def("switch_sfp_tx", &timing::FIBV2IONode::switch_sfp_tx)
105 .def("read_board_temperature", &timing::FIBV2IONode::read_board_temperature)
106 ;
107
108 py::class_<timing::TLUIONode, timing::IONode, uhal::Node>(m, "TLUIONode")
109 .def(py::init<const uhal::Node&>())
110 .def<void (timing::TLUIONode::*)(const std::string&) const>(
111 "reset", &timing::TLUIONode::reset, py::arg("clock_config_file"))
112 .def<void (timing::TLUIONode::*)(const timing::ClockSource&) const>(
113 "reset", &timing::TLUIONode::reset, py::arg("clock_source"))
114 .def("soft_reset", &timing::TLUIONode::soft_reset)
115 .def("read_firmware_frequency", &timing::TLUIONode::read_firmware_frequency)
116 .def("get_clock_frequencies_table", &timing::TLUIONode::get_clock_frequencies_table, py::arg("print_out") = false)
117 .def("get_status", &timing::TLUIONode::get_status, py::arg("print_out") = false)
118 .def("get_pll_status", &timing::TLUIONode::get_pll_status, py::arg("print_out") = false)
119 .def("get_hardware_info", &timing::TLUIONode::get_hardware_info, py::arg("print_out") = false)
120 .def("get_sfp_status", &timing::TLUIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
121 .def("switch_sfp_soft_tx_control_bit", &timing::TLUIONode::switch_sfp_soft_tx_control_bit)
122 .def("configure_dac",
123 &timing::TLUIONode::configure_dac,
124 py::arg("dac_id"),
125 py::arg("dac_value"),
126 py::arg("internal_ref") = false)
127 .def("switch_sfp_tx", &timing::TLUIONode::switch_sfp_tx);
128
129 py::class_<timing::SIMIONode, timing::IONode, uhal::Node>(m, "SIMIONode")
130 .def(py::init<const uhal::Node&>())
131 .def<void (timing::SIMIONode::*)(const std::string&) const>(
132 "reset", &timing::SIMIONode::reset, py::arg("clock_config_file"))
133 .def<void (timing::SIMIONode::*)(const timing::ClockSource&) const>(
134 "reset", &timing::SIMIONode::reset, py::arg("clock_source"))
135 .def("soft_reset", &timing::SIMIONode::soft_reset)
136 .def("read_firmware_frequency", &timing::SIMIONode::read_firmware_frequency)
137 .def("get_clock_frequencies_table", &timing::SIMIONode::get_clock_frequencies_table, py::arg("print_out") = false)
138 .def("get_status", &timing::SIMIONode::get_status, py::arg("print_out") = false)
139 .def("get_pll_status", &timing::SIMIONode::get_pll_status, py::arg("print_out") = false)
140 .def("get_hardware_info", &timing::SIMIONode::get_hardware_info, py::arg("print_out") = false)
141 .def("get_sfp_status", &timing::SIMIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
142 .def("switch_sfp_soft_tx_control_bit", &timing::SIMIONode::switch_sfp_soft_tx_control_bit)
143 .def("switch_sfp_tx", &timing::SIMIONode::switch_sfp_tx);
144
145 py::class_<timing::MIBIONode, timing::IONode, uhal::Node>(m, "MIBIONode")
146 .def(py::init<const uhal::Node&>())
147 .def<void (timing::MIBIONode::*)(const std::string&) const>(
148 "reset", &timing::MIBIONode::reset, py::arg("clock_config_file"))
149 .def<void (timing::MIBIONode::*)(const timing::ClockSource&) const>(
150 "reset", &timing::MIBIONode::reset, py::arg("clock_source"))
151 .def("soft_reset", &timing::MIBIONode::soft_reset)
152 .def("read_firmware_frequency", &timing::MIBIONode::read_firmware_frequency)
153 .def("get_clock_frequencies_table", &timing::MIBIONode::get_clock_frequencies_table, py::arg("print_out") = false)
154 .def("get_status", &timing::MIBIONode::get_status, py::arg("print_out") = false)
155 .def("get_pll_status", &timing::MIBIONode::get_pll_status, py::arg("print_out") = false)
156 .def("get_pll", &timing::MIBIONode::get_pll)
157 .def("get_hardware_info", &timing::MIBIONode::get_hardware_info, py::arg("print_out") = false)
158 .def("get_sfp_status", &timing::MIBIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
159 .def("switch_sfp_soft_tx_control_bit", &timing::MIBIONode::switch_sfp_soft_tx_control_bit)
160 .def("switch_sfp_tx", &timing::MIBIONode::switch_sfp_tx)
161 ;
162
163 py::class_<timing::SwitchyardNode, uhal::Node>(m, "SwitchyardNode")
164 .def("get_status", &timing::SwitchyardNode::get_status, py::arg("print_out") = false)
165 .def("configure_master_source", &timing::SwitchyardNode::configure_master_source, py::arg("master_source"), py::arg("dispatch") = true)
166 .def("configure_endpoint_source", &timing::SwitchyardNode::configure_endpoint_source, py::arg("endpoint_source"), py::arg("dispatch") = true);
167
168 py::class_<timing::MIBV3IONode, timing::IONode, uhal::Node>(m, "MIBV3IONode")
169 .def(py::init<const uhal::Node&>())
170 .def<void (timing::MIBV3IONode::*)(const std::string&) const>(
171 "reset", &timing::MIBV3IONode::reset, py::arg("clock_config_file"))
172 .def<void (timing::MIBV3IONode::*)(const timing::ClockSource&) const>(
173 "reset", &timing::MIBV3IONode::reset, py::arg("clock_source"))
174 .def("soft_reset", &timing::MIBV3IONode::soft_reset)
175 .def("read_firmware_frequency", &timing::MIBV3IONode::read_firmware_frequency)
176 .def("get_clock_frequencies_table", &timing::MIBV3IONode::get_clock_frequencies_table, py::arg("print_out") = false)
177 .def("get_status", &timing::MIBV3IONode::get_status, py::arg("print_out") = false)
178 .def("get_pll_status", &timing::MIBV3IONode::get_pll_status, py::arg("print_out") = false)
179 .def("get_pll", &timing::MIBV3IONode::get_pll)
180 .def("get_hardware_info", &timing::MIBV3IONode::get_hardware_info, py::arg("print_out") = false)
181 .def("get_sfp_status", &timing::MIBV3IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
182 .def("switch_sfp_soft_tx_control_bit", &timing::MIBV3IONode::switch_sfp_soft_tx_control_bit)
183 .def("switch_sfp_tx", &timing::MIBV3IONode::switch_sfp_tx)
184 ;
185
186 // TODO fix missing binding and add GIBv2/3 inheritance, dlindebaum, 2025.10.06
187 py::class_<timing::GIBIONode, timing::IONode, uhal::Node>(m, "GIBIONode")
188 .def(py::init<const uhal::Node&>())
189 .def<void (timing::GIBIONode::*)(const std::string&) const>(
190 "reset", &timing::GIBIONode::reset, py::arg("clock_config_file"))
191 .def<void (timing::GIBIONode::*)(const timing::ClockSource&) const>(
192 "reset", &timing::GIBIONode::reset, py::arg("clock_source"))
193 .def<void (timing::GIBIONode::*)(const std::string&) const>(
194 "configure_pll", &timing::GIBIONode::configure_pll, py::arg("clock_config_file"))
195 .def<void (timing::GIBIONode::*)(const timing::ClockSource&) const>(
196 "configure_pll", &timing::GIBIONode::configure_pll, py::arg("clock_source"))
197 .def("soft_reset", &timing::GIBIONode::soft_reset)
198 .def("read_firmware_frequency", &timing::GIBIONode::read_firmware_frequency)
199 .def("get_clock_frequencies_table", &timing::GIBIONode::get_clock_frequencies_table, py::arg("print_out") = false)
200 .def("get_full_clock_config_file_path", &timing::GIBIONode::get_full_clock_config_file_path, py::arg("clock_source"))
201 .def("get_status", &timing::GIBIONode::get_status, py::arg("print_out") = false)
202 .def("get_pll_status", &timing::GIBIONode::get_pll_status, py::arg("print_out") = false)
203 .def("get_pll", &timing::GIBIONode::get_pll)
204 .def("get_hardware_info", &timing::GIBIONode::get_hardware_info, py::arg("print_out") = false)
205 .def("set_up_io_infrastructure", &timing::GIBIONode::set_up_io_infrastructure)
206 .def("configure_expander", &timing::GIBIONode::configure_expander)
207 .def("reset_pll", &timing::GIBIONode::reset_pll)
208 .def("get_sfp_status", &timing::GIBIONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
209 .def("read_io_expanders", &timing::GIBIONode::read_io_expanders)
210 .def("read_sfps_los", &timing::GIBIONode::read_sfps_los)
211 .def("read_sfps_fault", &timing::GIBIONode::read_sfps_fault)
212 .def("clocks_ok", &timing::GIBIONode::clocks_ok)
213 .def("switch_sfp_soft_tx_control_bit", &timing::GIBIONode::switch_sfp_soft_tx_control_bit)
214 .def("set_i2c_mux_channels", &timing::GIBIONode::set_i2c_mux_channels)
215 .def("switch_sfp_tx", &timing::GIBIONode::switch_sfp_tx)
216 ;
217
218 py::class_<timing::GIBV2IONode, timing::IONode, uhal::Node>(m, "GIBV2IONode")
219 .def(py::init<const uhal::Node&>())
220 .def<void (timing::GIBV2IONode::*)(const std::string&) const>(
221 "reset", &timing::GIBV2IONode::reset, py::arg("clock_config_file"))
222 .def<void (timing::GIBV2IONode::*)(const timing::ClockSource&) const>(
223 "reset", &timing::GIBV2IONode::reset, py::arg("clock_source"))
224 .def<void (timing::GIBV2IONode::*)(const std::string&) const>(
225 "configure_pll", &timing::GIBV2IONode::configure_pll, py::arg("clock_config_file"))
226 .def<void (timing::GIBV2IONode::*)(const timing::ClockSource&) const>(
227 "configure_pll", &timing::GIBV2IONode::configure_pll, py::arg("clock_source"))
228 .def("soft_reset", &timing::GIBV2IONode::soft_reset)
229 .def("read_firmware_frequency", &timing::GIBV2IONode::read_firmware_frequency)
230 .def("get_full_clock_config_file_path", &timing::GIBV2IONode::get_full_clock_config_file_path, py::arg("clock_source"))
231 .def("get_clock_frequencies_table", &timing::GIBV2IONode::get_clock_frequencies_table, py::arg("print_out") = false)
232 .def("get_status", &timing::GIBV2IONode::get_status, py::arg("print_out") = false)
233 .def("get_pll_status", &timing::GIBV2IONode::get_pll_status, py::arg("print_out") = false)
234 .def("get_pll", &timing::GIBV2IONode::get_pll)
235 .def("get_hardware_info", &timing::GIBV2IONode::get_hardware_info, py::arg("print_out") = false)
236 .def("set_up_io_infrastructure", &timing::GIBV2IONode::set_up_io_infrastructure)
237 .def("configure_expander", &timing::GIBV2IONode::configure_expander)
238 .def("reset_pll", &timing::GIBV2IONode::reset_pll)
239 .def("get_sfp_status", &timing::GIBV2IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
240 .def("read_io_expanders", &timing::GIBV2IONode::read_io_expanders)
241 .def("read_sfps_los", &timing::GIBV2IONode::read_sfps_los)
242 .def("read_sfps_fault", &timing::GIBV2IONode::read_sfps_fault)
243 .def("clocks_ok", &timing::GIBV2IONode::clocks_ok)
244 .def("switch_sfp_soft_tx_control_bit", &timing::GIBV2IONode::switch_sfp_soft_tx_control_bit)
245 .def("set_i2c_mux_channels", &timing::GIBV2IONode::set_i2c_mux_channels)
246 .def("switch_sfp_tx", &timing::GIBV2IONode::switch_sfp_tx)
247 ;
248
249 py::class_<timing::GIBV3IONode, timing::IONode, uhal::Node>(m, "GIBV3IONode")
250 .def(py::init<const uhal::Node&>())
251 .def<void (timing::GIBV3IONode::*)(const std::string&) const>(
252 "reset", &timing::GIBV3IONode::reset, py::arg("clock_config_file"))
253 .def<void (timing::GIBV3IONode::*)(const timing::ClockSource&) const>(
254 "reset", &timing::GIBV3IONode::reset, py::arg("clock_source"))
255 .def<void (timing::GIBV3IONode::*)(const std::string&) const>(
256 "configure_pll", &timing::GIBV3IONode::configure_pll, py::arg("clock_config_file"))
257 .def<void (timing::GIBV3IONode::*)(const timing::ClockSource&) const>(
258 "configure_pll", &timing::GIBV3IONode::configure_pll, py::arg("clock_source"))
259 .def("soft_reset", &timing::GIBV3IONode::soft_reset)
260 .def("read_firmware_frequency", &timing::GIBV3IONode::read_firmware_frequency)
261 .def("get_full_clock_config_file_path", &timing::GIBV3IONode::get_full_clock_config_file_path, py::arg("clock_source"))
262 .def("get_clock_frequencies_table", &timing::GIBV3IONode::get_clock_frequencies_table, py::arg("print_out") = false)
263 .def("get_status", &timing::GIBV3IONode::get_status, py::arg("print_out") = false)
264 .def("get_pll_status", &timing::GIBV3IONode::get_pll_status, py::arg("print_out") = false)
265 .def("get_pll", &timing::GIBV3IONode::get_pll)
266 .def("get_hardware_info", &timing::GIBV3IONode::get_hardware_info, py::arg("print_out") = false)
267 .def("set_up_io_infrastructure", &timing::GIBV3IONode::set_up_io_infrastructure)
268 .def("configure_expander", &timing::GIBV3IONode::configure_expander)
269 .def("reset_pll", &timing::GIBV3IONode::reset_pll)
270 .def("get_sfp_status", &timing::GIBV3IONode::get_sfp_status, py::arg("sfp_id"), py::arg("print_out") = false)
271 .def("read_io_expanders", &timing::GIBV3IONode::read_io_expanders)
272 .def("read_sfps_los", &timing::GIBV3IONode::read_sfps_los)
273 .def("read_sfps_fault", &timing::GIBV3IONode::read_sfps_fault)
274 .def("clocks_ok", &timing::GIBV3IONode::clocks_ok)
275 .def("switch_sfp_soft_tx_control_bit", &timing::GIBV3IONode::switch_sfp_soft_tx_control_bit)
276 .def("set_i2c_mux_channels", &timing::GIBV3IONode::set_i2c_mux_channels)
277 .def("switch_sfp_tx", &timing::GIBV3IONode::switch_sfp_tx)
278 ;
279
280} // NOLINT
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:123
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:206
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:310
dunedaq::timing::GIBIONode::read_sfps_fault
virtual uint8_t read_sfps_fault() const
Retrive SFP fault status for all SFPs.
Definition GIBIONode.cpp:264
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:374
dunedaq::timing::GIBIONode::reset
void reset(const std::string &clock_config_file) const override
Reset GIB IO.
Definition GIBIONode.cpp:142
dunedaq::timing::GIBIONode::set_up_io_infrastructure
void set_up_io_infrastructure() const override
Set up i2c buses, enable ICs.
Definition GIBIONode.cpp:112
dunedaq::timing::GIBIONode::get_pll
std::unique_ptr< const SI534xSlave > get_pll() const override
GET PLL I2C interface.
Definition GIBIONode.cpp:92
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:300
dunedaq::timing::GIBIONode::read_io_expanders
virtual uint32_t read_io_expanders() const
Read the contents of the IO expanders.
Definition GIBIONode.cpp:233
dunedaq::timing::GIBIONode::get_hardware_info
std::string get_hardware_info(bool print_out) const override
Print hardware information.
Definition GIBIONode.cpp:102
dunedaq::timing::GIBIONode::reset_pll
void reset_pll() const override
Reset PLL.
Definition GIBIONode.cpp:201
dunedaq::timing::GIBIONode::configure_expander
void configure_expander() const
Configure the GIB expander.
Definition GIBIONode.cpp:174
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:210
dunedaq::timing::GIBIONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition GIBIONode.cpp:53
dunedaq::timing::GIBIONode::read_sfps_los
virtual uint8_t read_sfps_los() const
Retrive SFP LOS status for all SFPs.
Definition GIBIONode.cpp:247
dunedaq::timing::GIBIONode::clocks_ok
bool clocks_ok() const override
Clocks ready?
Definition GIBIONode.cpp:281
dunedaq::timing::GIBV2IONode
Class for the timing FMC board.
Definition GIBV2IONode.hpp:33
dunedaq::timing::GIBV2IONode::read_sfps_fault
uint8_t read_sfps_fault() const override
Retrive SFP fault status for all SFPs.
Definition GIBV2IONode.cpp:50
dunedaq::timing::GIBV2IONode::read_sfps_los
uint8_t read_sfps_los() const override
Retrive SFP LOS status for all SFPs.
Definition GIBV2IONode.cpp:32
dunedaq::timing::GIBV2IONode::clocks_ok
bool clocks_ok() const override
Clocks ready?
Definition GIBV2IONode.cpp:68
dunedaq::timing::GIBV2IONode::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 GIBV2IONode.cpp:85
dunedaq::timing::GIBV3IONode
Class for the timing FMC board.
Definition GIBV3IONode.hpp:33
dunedaq::timing::GIBV3IONode::read_io_expanders
uint32_t read_io_expanders() const override
Read the contents of the IO expanders.
Definition GIBV3IONode.cpp:71
dunedaq::timing::GIBV3IONode::read_sfps_los
uint8_t read_sfps_los() const override
Retrive SFP LOS status for all SFPs.
Definition GIBV3IONode.cpp:83
dunedaq::timing::GIBV3IONode::read_sfps_fault
uint8_t read_sfps_fault() const override
Retrive SFP fault status for all SFPs.
Definition GIBV3IONode.cpp:102
dunedaq::timing::GIBV3IONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition GIBV3IONode.cpp:32
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:347
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:328
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:306
dunedaq::timing::IONode::get_full_clock_config_file_path
virtual std::string get_full_clock_config_file_path(const ClockSource &clock_source) const
Get the full config path.
Definition IONode.cpp:167
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::configure_pll
virtual void configure_pll(const std::string &clock_config_file="") const
Configure clock chip.
Definition IONode.cpp:238
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:273
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:289
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::MIBV3IONode
Class for the timing FMC board.
Definition MIBV3IONode.hpp:33
dunedaq::timing::MIBV3IONode::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 MIBV3IONode.cpp:104
dunedaq::timing::MIBV3IONode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition MIBV3IONode.cpp:40
dunedaq::timing::MIBV3IONode::reset
void reset(const std::string &clock_config_file) const override
Reset MIB v2 IO.
Definition MIBV3IONode.cpp:55
dunedaq::timing::MIBV3IONode::switch_sfp_tx
void switch_sfp_tx(uint32_t sfp_id, bool turn_on) const override
control tx laser of on-board SFP
Definition MIBV3IONode.cpp:149
dunedaq::timing::MIBV3IONode::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 MIBV3IONode.cpp:139
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

◆ register_master()

void dunedaq::timing::python::register_master ( py::module & m)

Definition at line 23 of file master.cpp.

24{
25 py::class_<timing::MasterNode, uhal::Node>(m, "MasterNode")
26 .def(py::init<const uhal::Node&>())
27 .def("switch_endpoint_sfp", &timing::MasterNode::switch_endpoint_sfp)
28 .def("enable_upstream_endpoint", &timing::MasterNode::enable_upstream_endpoint)
29 .def("reset_command_counters", &timing::MasterNode::reset_command_counters)
30 .def("transmit_async_packet", &timing::MasterNode::transmit_async_packet, py::arg("packet"), py::arg("timeout") = 500) //timeout [us]
31 .def("write_endpoint_data", &timing::MasterNode::write_endpoint_data)
32 .def("read_endpoint_data", &timing::MasterNode::read_endpoint_data)
33 .def("send_fl_cmd",
34 &timing::MasterNode::send_fl_cmd,
35 py::arg("command"),
36 py::arg("channel"),
37 py::arg("number_of_commands") = 1)
38 .def<void (timing::MasterNode::*)(uint32_t, uint32_t, double, bool, uint32_t) const>("enable_periodic_fl_cmd",
39 &timing::MasterNode::enable_periodic_fl_cmd,
40 py::arg("command"),
41 py::arg("channel"),
42 py::arg("rate"),
43 py::arg("poisson"),
44 py::arg("clock_frequency_hz"))
45 .def("disable_periodic_fl_cmd", &timing::MasterNode::disable_periodic_fl_cmd)
46 .def("get_status", &timing::MasterNode::get_status, py::arg("print_out") = false)
47 .def("get_status_with_date", &timing::MasterNode::get_status_with_date, py::arg("clock_frequency_hz"), py::arg("print_out") = false)
48 .def("sync_timestamp", &timing::MasterNode::sync_timestamp, py::arg("source"))
49 .def("read_timestamp", &timing::MasterNode::read_timestamp)
50 .def("disable_timestamp_broadcast", &timing::MasterNode::disable_timestamp_broadcast)
51 .def("enable_timestamp_broadcast", &timing::MasterNode::enable_timestamp_broadcast)
52 .def("configure_endpoint_command_decoder", &timing::MasterNode::configure_endpoint_command_decoder,
53 py::arg("endpoint_address"),
54 py::arg("slot"),
55 py::arg("command"));
56
57 py::class_<timing::UpstreamCDRNode, uhal::Node>(m, "UpstreamCDRNode")
58 .def(py::init<const uhal::Node&>())
59 .def("get_status", &timing::UpstreamCDRNode::get_status, py::arg("print_out") = false)
60 .def("resync", &timing::UpstreamCDRNode::resync);
61
62 py::class_<timing::IRIGTimestampNode, uhal::Node>(m, "IRIGTimestampNode")
63 .def(py::init<const uhal::Node&>())
64 .def("get_status", &timing::IRIGTimestampNode::get_status, py::arg("print_out") = false)
65 .def("set_ts_timebase", &timing::IRIGTimestampNode::set_ts_timebase, py::arg("ts_timebase"))
66 .def("set_ts_epoch", &timing::IRIGTimestampNode::set_ts_epoch, py::arg("ts_epoch"))
67 .def("set_ts_epoch_value", &timing::IRIGTimestampNode::set_ts_epoch_value, py::arg("epoch_to_2000_seconds_tai"), py::arg("epoch_to_2000_leap_seconds"))
68 .def("set_ts_seconds_offset", &timing::IRIGTimestampNode::set_ts_seconds_offset, py::arg("seconds_offset"))
69 .def("set_ts_ticks_offset", &timing::IRIGTimestampNode::set_ts_ticks_offset, py::arg("ticks_offset"))
70 ;
71
72}
dunedaq::timing::IRIGTimestampNode::get_status
std::string get_status(bool print_out=false) const override
Print the status of the timing node.
Definition IRIGTimestampNode.cpp:33
dunedaq::timing::IRIGTimestampNode::set_ts_ticks_offset
void set_ts_ticks_offset(int16_t ticks_offset) const
Set ticks offset.
Definition IRIGTimestampNode.cpp:145
dunedaq::timing::IRIGTimestampNode::set_ts_epoch_value
void set_ts_epoch_value(uint64_t epoch_to_2000_seconds_tai, uint8_t epoch_to_2000_leap_seconds) const
Set custom epoch value.
Definition IRIGTimestampNode.cpp:102
dunedaq::timing::IRIGTimestampNode::set_ts_seconds_offset
void set_ts_seconds_offset(int8_t seconds_offset) const
Set seconds offset.
Definition IRIGTimestampNode.cpp:135
dunedaq::timing::IRIGTimestampNode::set_ts_timebase
void set_ts_timebase(TimestampTimebase ts_timebase) const
Set custom epoch date.
Definition IRIGTimestampNode.cpp:84
dunedaq::timing::IRIGTimestampNode::set_ts_epoch
void set_ts_epoch(TimestampEpoch ts_epoch) const
Set epoch: UNIX/custom.
Definition IRIGTimestampNode.cpp:93
dunedaq::timing::MasterNodeInterface::enable_periodic_fl_cmd
virtual void enable_periodic_fl_cmd(uint32_t channel, double rate, bool poisson, uint32_t clock_frequency_hz) const
Configure fake trigger generator.
Definition MasterNodeInterface.cpp:41
dunedaq::timing::MasterNodeInterface::disable_periodic_fl_cmd
virtual void disable_periodic_fl_cmd(uint32_t channel) const
Clear fake trigger configuration.
Definition MasterNodeInterface.cpp:58
dunedaq::timing::MasterNode
Class for PD-II/DUNE master timing nodes.
Definition MasterNode.hpp:39
dunedaq::timing::MasterNode::get_status
std::string get_status(bool print_out=false) const override
Print the status of the timing node.
Definition MasterNode.cpp:77
dunedaq::timing::MasterNode::get_status_with_date
std::string get_status_with_date(uint32_t clock_frequency_hz, bool print_out=false) const
Print the status of the timing node.
Definition MasterNode.cpp:92
dunedaq::timing::MasterNode::transmit_async_packet
std::vector< uint32_t > transmit_async_packet(const std::vector< uint32_t > &packet, int timeout=500) const
Send an async packet.
Definition MasterNode.cpp:380
dunedaq::timing::MasterNode::enable_timestamp_broadcast
void enable_timestamp_broadcast() const
Enable timestamp sending.
Definition MasterNode.cpp:514
dunedaq::timing::MasterNode::read_timestamp
uint64_t read_timestamp() const override
Read the current timestamp word.
Definition MasterNode.cpp:314
dunedaq::timing::MasterNode::read_endpoint_data
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.
Definition MasterNode.cpp:475
dunedaq::timing::MasterNode::switch_endpoint_sfp
void switch_endpoint_sfp(uint32_t address, bool turn_on) const override
Control the tx line of endpoint sfp.
Definition MasterNode.cpp:108
dunedaq::timing::MasterNode::disable_timestamp_broadcast
void disable_timestamp_broadcast() const
Disable timestamp sending.
Definition MasterNode.cpp:506
dunedaq::timing::MasterNode::enable_upstream_endpoint
void enable_upstream_endpoint() const override
Enable RTT endpoint.
Definition MasterNode.cpp:130
dunedaq::timing::MasterNode::sync_timestamp
void sync_timestamp(TimestampSource source) const override
Set timestamp to current machine time.
Definition MasterNode.cpp:300
dunedaq::timing::MasterNode::configure_endpoint_command_decoder
void configure_endpoint_command_decoder(uint16_t endpoint_address, uint8_t slot, uint8_t command) const
Configure endpoint command decoder.
Definition MasterNode.cpp:596
dunedaq::timing::MasterNode::reset_command_counters
void reset_command_counters() const
Read some data from endpoint registers.
Definition MasterNode.cpp:371
dunedaq::timing::MasterNode::write_endpoint_data
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.
Definition MasterNode.cpp:448
dunedaq::timing::MasterNode::send_fl_cmd
void send_fl_cmd(uint32_t command, uint32_t channel, uint32_t number_of_commands=1) const override
Send a fixed length command.
Definition MasterNode.cpp:139
dunedaq::timing::UpstreamCDRNode::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition UpstreamCDRNode.cpp:35

◆ register_toolbox()

void dunedaq::timing::python::register_toolbox ( py::module & m)
extern

Definition at line 21 of file toolbox.cpp.

22{
23 m.def("format_firmware_version", &timing::format_firmware_version);
24}
dunedaq::timing::format_firmware_version
std::string format_firmware_version(uint32_t firmware_version)
Definition toolbox.cpp:352

◆ register_top_designs()

void dunedaq::timing::python::register_top_designs ( py::module & m)
extern

Definition at line 29 of file top_designs.cpp.

30{
31 // Boreas
32 py::class_<timing::BoreasDesign, uhal::Node>(m, "BoreasDesign")
33 .def("read_firmware_version", &timing::BoreasDesign::read_firmware_version)
34 .def("validate_firmware_version", &timing::BoreasDesign::validate_firmware_version)
35 .def("sync_timestamp", &timing::BoreasDesign::sync_timestamp)
36 .def("get_status", &timing::BoreasDesign::get_status)
37 .def<void (timing::BoreasDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
38 &timing::BoreasDesign::enable_periodic_fl_cmd,
39 py::arg("channel"),
40 py::arg("rate"),
41 py::arg("poisson"))
42 .def<void (timing::BoreasDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
43 &timing::BoreasDesign::enable_periodic_fl_cmd,
44 py::arg("command"),
45 py::arg("channel"),
46 py::arg("rate"),
47 py::arg("poisson"))
48 .def("apply_endpoint_delay",
49 &timing::BoreasDesign::apply_endpoint_delay,
50 py::arg("address"),
51 py::arg("coarse_delay"),
52 py::arg("fine_delay"),
53 py::arg("phase_delay"),
54 py::arg("measure_rtt") = false,
55 py::arg("control_sfp") = true,
56 py::arg("sfp_mux") = -1)
57 .def("measure_endpoint_rtt",
58 &timing::BoreasDesign::measure_endpoint_rtt,
59 py::arg("address"),
60 py::arg("control_sfp") = true,
61 py::arg("sfp_mux") = -1)
62 .def("get_hsi_node", &timing::BoreasDesign::get_hsi_node)
63 .def("configure_hsi",
64 &timing::BoreasDesign::configure_hsi,
65 py::arg("src"),
66 py::arg("re_mask"),
67 py::arg("fe_mask"),
68 py::arg("inv_mask"),
69 py::arg("rate"),
70 py::arg("dispatch") = true)
71 .def("configure", &timing::BoreasDesign::configure, py::arg("clock_source"), py::arg("ts_source"))
72 ;
73
74 // Fanout
75 py::class_<timing::FanoutDesign, uhal::Node>(m, "FanoutDesign")
76 .def("read_firmware_version", &timing::FanoutDesign::read_firmware_version)
77 .def("validate_firmware_version", &timing::FanoutDesign::validate_firmware_version)
78 .def("switch_mux", &timing::FanoutDesign::switch_mux, py::arg("mux"), py::arg("resync_cdr") = false)
79 .def("read_active_mux", &timing::FanoutDesign::read_active_mux)
80 .def("configure", &timing::FanoutDesign::configure, py::arg("clock_source"))
81 ;
82
83 // Ouroboros mux
84 py::class_<timing::OuroborosMuxDesign, uhal::Node>(m, "OuroborosMuxDesign")
85 .def("read_firmware_version", &timing::OuroborosMuxDesign::read_firmware_version)
86 .def("validate_firmware_version", &timing::OuroborosMuxDesign::validate_firmware_version)
87 .def("sync_timestamp", &timing::OuroborosMuxDesign::sync_timestamp)
88 .def<void (timing::OuroborosMuxDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
89 &timing::OuroborosMuxDesign::enable_periodic_fl_cmd,
90 py::arg("channel"),
91 py::arg("rate"),
92 py::arg("poisson"))
93 .def<void (timing::OuroborosMuxDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
94 &timing::OuroborosMuxDesign::enable_periodic_fl_cmd,
95 py::arg("command"),
96 py::arg("channel"),
97 py::arg("rate"),
98 py::arg("poisson"))
99 .def("switch_mux", &timing::OuroborosMuxDesign::switch_mux, py::arg("mux"), py::arg("resync_cdr") = false)
100 .def("read_active_mux", &timing::OuroborosMuxDesign::read_active_mux)
101 .def("apply_endpoint_delay",
102 &timing::OuroborosMuxDesign::apply_endpoint_delay,
103 py::arg("address"),
104 py::arg("coarse_delay"),
105 py::arg("fine_delay"),
106 py::arg("phase_delay"),
107 py::arg("measure_rtt") = false,
108 py::arg("control_sfp") = true,
109 py::arg("sfp_mux") = -1)
110 .def("measure_endpoint_rtt",
111 &timing::OuroborosMuxDesign::measure_endpoint_rtt,
112 py::arg("address"),
113 py::arg("control_sfp") = true,
114 py::arg("sfp_mux") = -1)
115 .def("scan_sfp_mux", &timing::OuroborosMuxDesign::scan_sfp_mux)
116 .def("configure", &timing::OuroborosMuxDesign::configure, py::arg("clock_source"), py::arg("ts_source"))
117 ;
118
119 // Master mux
120 py::class_<timing::MasterMuxDesign, uhal::Node>(m, "MasterMuxDesign")
121 .def("read_firmware_version", &timing::MasterMuxDesign::read_firmware_version)
122 .def("validate_firmware_version", &timing::MasterMuxDesign::validate_firmware_version)
123 .def("sync_timestamp", &timing::MasterMuxDesign::sync_timestamp)
124 .def<void (timing::MasterMuxDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
125 &timing::MasterMuxDesign::enable_periodic_fl_cmd,
126 py::arg("channel"),
127 py::arg("rate"),
128 py::arg("poisson"))
129 .def<void (timing::MasterMuxDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
130 &timing::MasterMuxDesign::enable_periodic_fl_cmd,
131 py::arg("command"),
132 py::arg("channel"),
133 py::arg("rate"),
134 py::arg("poisson"))
135 .def("switch_mux", &timing::MasterMuxDesign::switch_mux, py::arg("mux"), py::arg("resync_cdr") = false)
136 .def("read_active_mux", &timing::MasterMuxDesign::read_active_mux)
137 .def("apply_endpoint_delay",
138 &timing::MasterMuxDesign::apply_endpoint_delay,
139 py::arg("address"),
140 py::arg("coarse_delay"),
141 py::arg("fine_delay"),
142 py::arg("phase_delay"),
143 py::arg("measure_rtt") = false,
144 py::arg("control_sfp") = true,
145 py::arg("sfp_mux") = -1)
146 .def("measure_endpoint_rtt",
147 &timing::MasterMuxDesign::measure_endpoint_rtt,
148 py::arg("address"),
149 py::arg("control_sfp") = true,
150 py::arg("sfp_mux") = -1)
151 .def("scan_sfp_mux", &timing::MasterMuxDesign::scan_sfp_mux)
152 .def("configure", &timing::MasterMuxDesign::configure, py::arg("clock_source"), py::arg("ts_source"))
153 ;
154
155 // Master
156 py::class_<timing::MasterDesign, uhal::Node>(m, "MasterDesign")
157 .def("read_firmware_version", &timing::MasterDesign::read_firmware_version)
158 .def("validate_firmware_version", &timing::MasterDesign::validate_firmware_version)
159 .def("sync_timestamp", &timing::MasterDesign::sync_timestamp)
160 .def("get_status", &timing::MasterDesign::get_status)
161 .def<void (timing::MasterDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
162 &timing::MasterDesign::enable_periodic_fl_cmd,
163 py::arg("channel"),
164 py::arg("rate"),
165 py::arg("poisson"))
166 .def<void (timing::MasterDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
167 &timing::MasterDesign::enable_periodic_fl_cmd,
168 py::arg("command"),
169 py::arg("channel"),
170 py::arg("rate"),
171 py::arg("poisson"))
172 .def("apply_endpoint_delay",
173 &timing::MasterDesign::apply_endpoint_delay,
174 py::arg("address"),
175 py::arg("coarse_delay"),
176 py::arg("fine_delay"),
177 py::arg("phase_delay"),
178 py::arg("measure_rtt") = false,
179 py::arg("control_sfp") = true,
180 py::arg("sfp_mux") = -1)
181 .def("measure_endpoint_rtt",
182 &timing::MasterDesign::measure_endpoint_rtt,
183 py::arg("address"),
184 py::arg("control_sfp") = true,
185 py::arg("sfp_mux") = -1)
186 .def("configure", &timing::MasterDesign::configure, py::arg("clock_source"), py::arg("ts_source"))
187 ;
188
189 // Ouroboros
190 py::class_<timing::OuroborosDesign, uhal::Node>(m, "OuroborosDesign")
191 .def("read_firmware_version", &timing::OuroborosDesign::read_firmware_version)
192 .def("validate_firmware_version", &timing::OuroborosDesign::validate_firmware_version)
193 .def("sync_timestamp", &timing::OuroborosDesign::sync_timestamp)
194 .def("get_status", &timing::OuroborosDesign::get_status)
195 .def<void (timing::OuroborosDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
196 &timing::OuroborosDesign::enable_periodic_fl_cmd,
197 py::arg("channel"),
198 py::arg("rate"),
199 py::arg("poisson"))
200 .def<void (timing::OuroborosDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
201 &timing::OuroborosDesign::enable_periodic_fl_cmd,
202 py::arg("command"),
203 py::arg("channel"),
204 py::arg("rate"),
205 py::arg("poisson"))
206 .def("apply_endpoint_delay",
207 &timing::OuroborosDesign::apply_endpoint_delay,
208 py::arg("address"),
209 py::arg("coarse_delay"),
210 py::arg("fine_delay"),
211 py::arg("phase_delay"),
212 py::arg("measure_rtt") = false,
213 py::arg("control_sfp") = true,
214 py::arg("sfp_mux") = -1)
215 .def("measure_endpoint_rtt",
216 &timing::OuroborosDesign::measure_endpoint_rtt,
217 py::arg("address"),
218 py::arg("control_sfp") = true,
219 py::arg("sfp_mux") = -1)
220 .def("configure", &timing::OuroborosDesign::configure, py::arg("clock_source"), py::arg("ts_source"))
221 ;
222
223 // Endpoint
224 py::class_<timing::EndpointDesign, uhal::Node>(m, "EndpointDesign")
225 .def("read_firmware_version", &timing::EndpointDesign::read_firmware_version)
226 .def("validate_firmware_version", &timing::EndpointDesign::validate_firmware_version)
227 .def("get_status", &timing::EndpointDesign::get_status)
228 .def("configure", &timing::EndpointDesign::configure, py::arg("clock_source"))
229 ;
230
231 // Chronos
232 py::class_<timing::ChronosDesign, uhal::Node>(m, "ChronosDesign")
233 .def("read_firmware_version", &timing::ChronosDesign::read_firmware_version)
234 .def("validate_firmware_version", &timing::ChronosDesign::validate_firmware_version)
235 .def("get_status", &timing::ChronosDesign::get_status)
236 .def("get_hsi_node", &timing::ChronosDesign::get_hsi_node)
237 .def("configure_hsi",
238 &timing::ChronosDesign::configure_hsi,
239 py::arg("src"),
240 py::arg("re_mask"),
241 py::arg("fe_mask"),
242 py::arg("inv_mask"),
243 py::arg("rate"),
244 py::arg("dispatch") = true)
245 .def("configure", &timing::ChronosDesign::configure, py::arg("clock_source"))
246 ;
247
248 // Hades
249 py::class_<timing::HadesDesign, uhal::Node>(m, "HadesDesign")
250 .def("read_firmware_version", &timing::HadesDesign::read_firmware_version)
251 .def("validate_firmware_version", &timing::HadesDesign::validate_firmware_version)
252 .def("get_status", &timing::HadesDesign::get_status)
253 .def("get_hsi_node", &timing::HadesDesign::get_hsi_node)
254 .def("configure_hsi",
255 &timing::HadesDesign::configure_hsi,
256 py::arg("src"),
257 py::arg("re_mask"),
258 py::arg("fe_mask"),
259 py::arg("inv_mask"),
260 py::arg("rate"),
261 py::arg("dispatch") = true)
262 .def("configure", &timing::HadesDesign::configure, py::arg("clock_source"))
263 ;
264
265 // Kerberos
266 py::class_<timing::KerberosDesign, uhal::Node>(m, "KerberosDesign")
267 .def("read_firmware_version", &timing::KerberosDesign::read_firmware_version)
268 .def("validate_firmware_version", &timing::KerberosDesign::validate_firmware_version)
269 .def("sync_timestamp", &timing::KerberosDesign::sync_timestamp)
270 .def<void (timing::KerberosDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
271 &timing::KerberosDesign::enable_periodic_fl_cmd,
272 py::arg("channel"),
273 py::arg("rate"),
274 py::arg("poisson"))
275 .def<void (timing::KerberosDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
276 &timing::KerberosDesign::enable_periodic_fl_cmd,
277 py::arg("command"),
278 py::arg("channel"),
279 py::arg("rate"),
280 py::arg("poisson"))
281 .def("apply_endpoint_delay",
282 &timing::KerberosDesign::apply_endpoint_delay,
283 py::arg("address"),
284 py::arg("coarse_delay"),
285 py::arg("fine_delay"),
286 py::arg("phase_delay"),
287 py::arg("measure_rtt") = false,
288 py::arg("control_sfp") = true,
289 py::arg("sfp_mux") = -1)
290 .def("measure_endpoint_rtt",
291 &timing::KerberosDesign::measure_endpoint_rtt,
292 py::arg("address"),
293 py::arg("control_sfp") = true,
294 py::arg("sfp_mux") = -1)
295 .def("switch_mux", &timing::KerberosDesign::switch_mux, py::arg("mux"), py::arg("resync_cdr") = false)
296 .def("read_active_mux", &timing::KerberosDesign::read_active_mux)
297 .def("configure", &timing::KerberosDesign::configure, py::arg("clock_source"), py::arg("ts_source"))
298 .def("switch_timing_source_mux", &timing::KerberosDesign::switch_timing_source_mux, py::arg("mux_channel"))
299 .def("switch_timing_source", &timing::KerberosDesign::switch_timing_source, py::arg("clock_source"))
300 .def("read_active_timing_source_mux", &timing::KerberosDesign::read_active_timing_source_mux)
301 ;
302
303 // Gaia
304 py::class_<timing::GaiaDesign, uhal::Node>(m, "GaiaDesign")
305 .def("read_firmware_version", &timing::GaiaDesign::read_firmware_version)
306 .def("validate_firmware_version", &timing::GaiaDesign::validate_firmware_version)
307 .def("sync_timestamp", &timing::GaiaDesign::sync_timestamp)
308 .def<void (timing::GaiaDesign::*)(uint32_t, double, bool) const>("enable_periodic_fl_cmd",
309 &timing::GaiaDesign::enable_periodic_fl_cmd,
310 py::arg("channel"),
311 py::arg("rate"),
312 py::arg("poisson"))
313 .def<void (timing::GaiaDesign::*)(uint32_t, uint32_t, double, bool) const>("enable_periodic_fl_cmd",
314 &timing::GaiaDesign::enable_periodic_fl_cmd,
315 py::arg("command"),
316 py::arg("channel"),
317 py::arg("rate"),
318 py::arg("poisson"))
319 .def("apply_endpoint_delay",
320 &timing::GaiaDesign::apply_endpoint_delay,
321 py::arg("address"),
322 py::arg("coarse_delay"),
323 py::arg("fine_delay"),
324 py::arg("phase_delay"),
325 py::arg("measure_rtt") = false,
326 py::arg("control_sfp") = true,
327 py::arg("sfp_mux") = -1)
328 .def("measure_endpoint_rtt",
329 &timing::GaiaDesign::measure_endpoint_rtt,
330 py::arg("address"),
331 py::arg("control_sfp") = true,
332 py::arg("sfp_mux") = -1)
333 .def("switch_mux", &timing::GaiaDesign::switch_mux, py::arg("mux"), py::arg("resync_cdr") = false)
334 .def("read_active_mux", &timing::GaiaDesign::read_active_mux)
335 .def<void (timing::GaiaDesign::*)(ClockSource, TimestampSource, TimestampTimebase) const>("configure", &timing::GaiaDesign::configure, py::arg("clock_source"), py::arg("ts_source"), py::arg("timebase"))
336 ;
337} // NOLINT
dunedaq::timing::BoreasDesign
Class for timing master with integrated HSI designs.
Definition BoreasDesign.hpp:35
dunedaq::timing::BoreasDesign::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition BoreasDesign.cpp:35
dunedaq::timing::BoreasDesign::configure
void configure(ClockSource clock_source, TimestampSource ts_source) const override
Prepare the timing master for data taking.
Definition BoreasDesign.cpp:50
dunedaq::timing::CDRMuxDesignInterface::read_active_mux
uint8_t read_active_mux() const override
Read cdr mux.
Definition CDRMuxDesignInterface.hpp:48
dunedaq::timing::CDRMuxDesignInterface::switch_mux
void switch_mux(uint8_t mux_channel, bool resync_cdr=false) const override
Switch cdr mux.
Definition CDRMuxDesignInterface.hpp:60
dunedaq::timing::ChronosDesign::read_firmware_version
uint32_t read_firmware_version() const override
Read endpoint firmware version.
Definition ChronosDesign.hpp:57
dunedaq::timing::ChronosDesign::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition ChronosDesign.cpp:34
dunedaq::timing::ChronosDesign::configure
void configure(ClockSource clock_source) const override
Prepare the timing endpoint for data taking.
Definition ChronosDesign.cpp:48
dunedaq::timing::ChronosDesign::validate_firmware_version
void validate_firmware_version() const override
Validate endpoint firmware version.
Definition ChronosDesign.hpp:66
dunedaq::timing::EndpointDesign::read_firmware_version
uint32_t read_firmware_version() const override
Give info to collector.
Definition EndpointDesign.cpp:70
dunedaq::timing::EndpointDesign::configure
void configure(ClockSource clock_source) const override
Prepare the timing endpoint for data taking.
Definition EndpointDesign.cpp:51
dunedaq::timing::EndpointDesign::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition EndpointDesign.cpp:34
dunedaq::timing::EndpointDesign::validate_firmware_version
void validate_firmware_version() const override
Validate endpoint firmware version.
Definition EndpointDesign.cpp:79
dunedaq::timing::FanoutDesign::configure
void configure(ClockSource clock_source) const override
Give info to collector.
Definition FanoutDesign.cpp:57
dunedaq::timing::FanoutDesign::read_firmware_version
uint32_t read_firmware_version() const override
Read firmware version.
Definition FanoutDesign.cpp:48
dunedaq::timing::FanoutDesign::validate_firmware_version
void validate_firmware_version() const override
Validate endpoint firmware version.
Definition FanoutDesign.cpp:40
dunedaq::timing::GaiaDesign
Class for timing fanout designs.
Definition GaiaDesign.hpp:37
dunedaq::timing::GaiaDesign::configure
void configure(ClockSource clock_source, TimestampSource ts_source, TimestampTimebase timebase) const
Give info to collector.
Definition GaiaDesign.cpp:44
dunedaq::timing::HSIDesignInterface::configure_hsi
virtual void configure_hsi(uint32_t src, uint32_t re_mask, uint32_t fe_mask, uint32_t inv_mask, double rate, bool dispatch=true) const
Configure the HSI node.
Definition HSIDesignInterface.hpp:69
dunedaq::timing::HSIDesignInterface::get_hsi_node
virtual const HSINode & get_hsi_node() const
Get the HSI node.
Definition HSIDesignInterface.hpp:51
dunedaq::timing::KerberosDesign
Class for timing fanout designs.
Definition KerberosDesign.hpp:38
dunedaq::timing::KerberosDesign::configure
void configure(ClockSource clock_source, TimestampSource ts_source) const override
Give info to collector.
Definition KerberosDesign.cpp:43
dunedaq::timing::KerberosDesign::switch_timing_source
void switch_timing_source(ClockSource clock_source) const override
Switch timing source.
Definition KerberosDesign.cpp:94
dunedaq::timing::MasterDesign
Base class for timing master designs.
Definition MasterDesign.hpp:34
dunedaq::timing::MasterDesign::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition MasterDesign.cpp:25
dunedaq::timing::MasterDesign::apply_endpoint_delay
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, int sfp_mux=-1) const override
Apply delay to endpoint.
Definition MasterDesign.cpp:74
dunedaq::timing::MasterDesign::measure_endpoint_rtt
uint32_t measure_endpoint_rtt(uint32_t address, bool control_sfp=true, int sfp_mux=-1) const override
Measure the endpoint round trip time.
Definition MasterDesign.cpp:66
dunedaq::timing::MasterDesign::sync_timestamp
void sync_timestamp(TimestampSource source) const override
Sync timestamp to current machine value.
Definition MasterDesign.cpp:58
dunedaq::timing::MasterDesign::validate_firmware_version
void validate_firmware_version() const override
Validate master firmware version.
Definition MasterDesign.cpp:117
dunedaq::timing::MasterDesign::enable_periodic_fl_cmd
void enable_periodic_fl_cmd(uint32_t channel, double rate, bool poisson=false) const override
Configure fake trigger generator.
Definition MasterDesign.cpp:88
dunedaq::timing::MasterDesign::read_firmware_version
uint32_t read_firmware_version() const override
Read master firmware version.
Definition MasterDesign.cpp:106
dunedaq::timing::MasterDesign::configure
void configure(ClockSource clock_source, TimestampSource ts_source) const override
Prepare the timing master for data taking.
Definition MasterDesign.cpp:39
dunedaq::timing::MasterMuxDesign
Class for PDI timing master design on mux board.
Definition MasterMuxDesign.hpp:36
dunedaq::timing::MasterMuxDesign::scan_sfp_mux
std::vector< uint32_t > scan_sfp_mux() const override
Scan SFP for alive timing transmitters.
Definition MasterMuxDesign.cpp:88
dunedaq::timing::MasterMuxDesign::measure_endpoint_rtt
uint32_t measure_endpoint_rtt(uint32_t address, bool control_sfp=true, int sfp_mux=-1) const override
Measure the endpoint round trip time.
Definition MasterMuxDesign.cpp:41
dunedaq::timing::MasterMuxDesign::apply_endpoint_delay
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, int sfp_mux=-1) const override
Apply delay to endpoint.
Definition MasterMuxDesign.cpp:61
dunedaq::timing::MuxDesignInterface::read_active_mux
virtual uint8_t read_active_mux() const =0
Read cdr mux.
dunedaq::timing::MuxDesignInterface::switch_mux
virtual void switch_mux(uint8_t mux_channel, bool resync_cdr=false) const =0
Switch cdr mux.
dunedaq::timing::OuroborosDesign
Class for PDI timing master design (known as overlord).
Definition OuroborosDesign.hpp:35
dunedaq::timing::OuroborosDesign::configure
void configure(ClockSource clock_source, TimestampSource ts_source) const override
Prepare the timing master for data taking.
Definition OuroborosDesign.cpp:48
dunedaq::timing::OuroborosDesign::get_status
std::string get_status(bool print_out=false) const override
Get status string, optionally print.
Definition OuroborosDesign.cpp:34
dunedaq::timing::OuroborosMuxDesign
Class for PDI ouroboros timing master design.
Definition OuroborosMuxDesign.hpp:35
dunedaq::timing::TimingSourceMuxDesignInterface::switch_timing_source_mux
virtual void switch_timing_source_mux(uint8_t mux_channel) const
Switch timing source mux.
Definition TimingSourceMuxDesignInterface.hpp:58
dunedaq::timing::TimingSourceMuxDesignInterface::read_active_timing_source_mux
virtual uint8_t read_active_timing_source_mux() const
Read timing source mux.
Definition TimingSourceMuxDesignInterface.hpp:46

◆ swap_commands_map()

std::map< std::string, FixedLengthCommandType > dunedaq::timing::python::swap_commands_map ( const std::map< FixedLengthCommandType, std::string > & command_map)

Definition at line 28 of file definitions.cpp.

29{
30 std::map<std::string, FixedLengthCommandType> swapped_map;
31 for (auto& cmd: command_map) {
32 swapped_map.emplace( std::pair<std::string,FixedLengthCommandType>(cmd.second, cmd.first) );
33 }
34 return swapped_map;
35}
Generated on for DUNE-DAQ by doxygen 1.16.1