Line data Source code
1 : /**
2 : * @file TimingHardwareManagerPDII.cpp TimingHardwareManagerPDII class
3 : * implementation
4 : *
5 : * This is part of the DUNE DAQ Software Suite, copyright 2020.
6 : * Licensing/copyright details are in the COPYING file that you should have
7 : * received with this code.
8 : */
9 :
10 : #include "TimingHardwareManagerPDII.hpp"
11 : #include "timinglibs/dal/TimingHardwareManagerPDII.hpp"
12 :
13 : #include "timinglibs/TimingIssues.hpp"
14 : #include "timinglibs/timingcmd/Nljs.hpp"
15 : #include "timinglibs/timingcmd/Structs.hpp"
16 :
17 : #include "timing/MasterNode.hpp"
18 :
19 : #include "ers/Issue.hpp"
20 : #include "logging/Logging.hpp"
21 :
22 : #include <chrono>
23 : #include <cstdlib>
24 : #include <memory>
25 : #include <string>
26 : #include <thread>
27 : #include <vector>
28 :
29 : namespace dunedaq {
30 : namespace timinglibs {
31 :
32 0 : TimingHardwareManagerPDII::TimingHardwareManagerPDII(const std::string& name)
33 0 : : TimingHardwareManagerBase(name)
34 : {
35 0 : register_command("conf", &TimingHardwareManagerPDII::conf);
36 0 : register_command("start", &TimingHardwareManagerPDII::start);
37 0 : register_command("stop", &TimingHardwareManagerPDII::stop);
38 0 : }
39 :
40 : void
41 0 : TimingHardwareManagerPDII::conf(const CommandData_t& conf_data)
42 : {
43 0 : register_common_hw_commands_for_design();
44 0 : register_master_hw_commands_for_design();
45 0 : register_endpoint_hw_commands_for_design();
46 0 : register_hsi_hw_commands_for_design();
47 :
48 0 : TimingHardwareManagerBase::conf(conf_data);
49 :
50 : // monitoring
51 : // only register monitor threads if we have been given the name of the device to monitor
52 0 : if (m_monitored_device_name_master.compare("")) {
53 0 : register_info_gatherer(m_gather_interval, m_monitored_device_name_master, 1);
54 : // register_info_gatherer(m_gather_interval_debug, m_monitored_device_name_master, 2);
55 : }
56 :
57 0 : for (auto fanout : m_monitored_device_names_fanout) {
58 0 : register_info_gatherer(m_gather_interval, fanout.second, 1);
59 : // register_info_gatherer(m_gather_interval_debug, *it, 2);
60 0 : }
61 :
62 0 : if (m_monitored_device_name_endpoint.compare("")) {
63 0 : register_info_gatherer(m_gather_interval, m_monitored_device_name_endpoint, 1);
64 : // register_info_gatherer(m_gather_interval_debug, m_monitored_device_name_endpoint, 2);
65 : }
66 :
67 0 : if (m_monitored_device_name_hsi.compare("")) {
68 0 : register_info_gatherer(m_gather_interval, m_monitored_device_name_hsi, 1);
69 : // register_info_gatherer(m_gather_interval_debug, m_monitored_device_name_hsi, 2);
70 : }
71 :
72 0 : start_hw_mon_gathering();
73 0 : } // NOLINT
74 :
75 : void
76 0 : TimingHardwareManagerPDII::start(const CommandData_t& /*data*/)
77 : {
78 0 : }
79 : void
80 0 : TimingHardwareManagerPDII::stop(const CommandData_t& /*data*/)
81 : {
82 0 : }
83 :
84 : void
85 0 : TimingHardwareManagerPDII::register_common_hw_commands_for_design()
86 : {
87 0 : register_timing_hw_command("io_reset", &TimingHardwareManagerPDII::io_reset);
88 0 : register_timing_hw_command("print_status", &TimingHardwareManagerPDII::print_status);
89 0 : }
90 :
91 : void
92 0 : TimingHardwareManagerPDII::register_master_hw_commands_for_design()
93 : {
94 0 : register_timing_hw_command("set_timestamp", &TimingHardwareManagerPDII::set_timestamp);
95 0 : register_timing_hw_command("set_endpoint_delay", &TimingHardwareManagerPDII::set_endpoint_delay);
96 0 : register_timing_hw_command("send_fl_command", &TimingHardwareManagerPDII::send_fl_cmd);
97 0 : register_timing_hw_command("master_endpoint_scan", &TimingHardwareManagerPDII::master_endpoint_scan);
98 0 : }
99 :
100 : void
101 0 : TimingHardwareManagerPDII::register_endpoint_hw_commands_for_design()
102 : {
103 0 : register_timing_hw_command("endpoint_enable", &TimingHardwareManagerPDII::endpoint_enable);
104 0 : register_timing_hw_command("endpoint_disable", &TimingHardwareManagerPDII::endpoint_disable);
105 0 : register_timing_hw_command("endpoint_reset", &TimingHardwareManagerPDII::endpoint_reset);
106 0 : }
107 :
108 : void
109 0 : TimingHardwareManagerPDII::register_hsi_hw_commands_for_design()
110 : {
111 0 : register_timing_hw_command("hsi_reset", &TimingHardwareManagerPDII::hsi_reset);
112 0 : register_timing_hw_command("hsi_configure", &TimingHardwareManagerPDII::hsi_configure);
113 0 : register_timing_hw_command("hsi_start", &TimingHardwareManagerPDII::hsi_start);
114 0 : register_timing_hw_command("hsi_stop", &TimingHardwareManagerPDII::hsi_stop);
115 0 : register_timing_hw_command("hsi_print_status", &TimingHardwareManagerPDII::hsi_print_status);
116 0 : }
117 :
118 : // void
119 : // TimingHardwareManagerPDII::get_info(opmonlib::InfoCollector& ci, int level)
120 : // {
121 :
122 : // // send counters internal to the module
123 : // timinghardwaremanagerpdiinfo::Info module_info;
124 : // module_info.received_hw_commands_counter = m_received_hw_commands_counter.load();
125 : // module_info.accepted_hw_commands_counter = m_accepted_hw_commands_counter.load();
126 : // module_info.rejected_hw_commands_counter = m_rejected_hw_commands_counter.load();
127 : // module_info.failed_hw_commands_counter = m_failed_hw_commands_counter.load();
128 :
129 : // ci.add(module_info);
130 :
131 : // // the hardware device data
132 : // for (auto it = m_info_gatherers.begin(); it != m_info_gatherers.end(); ++it) {
133 : // // master info
134 : // if (m_monitored_device_name_master.find(it->second.get()->get_device_name()) != std::string::npos) {
135 : // if (it->second.get()->get_op_mon_level() <= level) {
136 : // it->second.get()->add_info_to_collector("master", ci);
137 : // }
138 : // }
139 :
140 : // for (uint i = 0; i < m_monitored_device_names_fanout.size(); ++i) {
141 : // std::string fanout_device_name = m_monitored_device_names_fanout.at(i);
142 : // if (fanout_device_name.find(it->second.get()->get_device_name()) != std::string::npos) {
143 : // if (it->second.get()->get_op_mon_level() <= level) {
144 : // it->second.get()->add_info_to_collector("fanout_" + std::to_string(i), ci);
145 : // }
146 : // }
147 : // }
148 :
149 : // if (m_monitored_device_name_endpoint.find(it->second.get()->get_device_name()) != std::string::npos) {
150 : // if (it->second.get()->get_op_mon_level() <= level) {
151 : // it->second.get()->add_info_to_collector("endpoint", ci);
152 : // }
153 : // }
154 :
155 : // if (m_monitored_device_name_hsi.find(it->second.get()->get_device_name()) != std::string::npos) {
156 : // if (it->second.get()->get_op_mon_level() <= level) {
157 : // it->second.get()->add_info_to_collector("hsi", ci);
158 : // }
159 : // }
160 : // }
161 : // }
162 :
163 : } // namespace timinglibs
164 : } // namespace dunedaq
165 :
166 0 : DEFINE_DUNE_DAQ_MODULE(dunedaq::timinglibs::TimingHardwareManagerPDII)
167 :
168 : // Local Variables:
169 : // c-basic-offset: 2
170 : // End:
|
