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/timingcmd/Nljs.hpp"
14 : #include "timinglibs/timingcmd/Structs.hpp"
15 : #include "timinglibs/TimingIssues.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 :
39 0 : }
40 :
41 : void
42 0 : TimingHardwareManagerPDII::conf(const CommandData_t& conf_data)
43 : {
44 0 : register_common_hw_commands_for_design();
45 0 : register_master_hw_commands_for_design();
46 0 : register_endpoint_hw_commands_for_design();
47 0 : register_hsi_hw_commands_for_design();
48 :
49 0 : TimingHardwareManagerBase::conf(conf_data);
50 :
51 : // monitoring
52 : // only register monitor threads if we have been given the name of the device to monitor
53 0 : if (m_monitored_device_name_master.compare("")) {
54 0 : register_info_gatherer(m_gather_interval, m_monitored_device_name_master, 1);
55 : //register_info_gatherer(m_gather_interval_debug, m_monitored_device_name_master, 2);
56 : }
57 :
58 0 : for (auto fanout : m_monitored_device_names_fanout) {
59 0 : register_info_gatherer(m_gather_interval, fanout.second, 1);
60 : //register_info_gatherer(m_gather_interval_debug, *it, 2);
61 0 : }
62 :
63 0 : if (m_monitored_device_name_endpoint.compare("")) {
64 0 : register_info_gatherer(m_gather_interval, m_monitored_device_name_endpoint, 1);
65 : //register_info_gatherer(m_gather_interval_debug, m_monitored_device_name_endpoint, 2);
66 : }
67 :
68 0 : if (m_monitored_device_name_hsi.compare("")) {
69 0 : register_info_gatherer(m_gather_interval, m_monitored_device_name_hsi, 1);
70 : //register_info_gatherer(m_gather_interval_debug, m_monitored_device_name_hsi, 2);
71 : }
72 :
73 0 : start_hw_mon_gathering();
74 0 : } // NOLINT
75 :
76 : void
77 0 : TimingHardwareManagerPDII::start(const CommandData_t& /*data*/)
78 : {
79 0 : }
80 : void
81 0 : TimingHardwareManagerPDII::stop(const CommandData_t& /*data*/)
82 : {
83 0 : }
84 :
85 : void
86 0 : TimingHardwareManagerPDII::register_common_hw_commands_for_design()
87 : {
88 0 : register_timing_hw_command("io_reset", &TimingHardwareManagerPDII::io_reset);
89 0 : register_timing_hw_command("print_status", &TimingHardwareManagerPDII::print_status);
90 0 : }
91 :
92 : void
93 0 : TimingHardwareManagerPDII::register_master_hw_commands_for_design()
94 : {
95 0 : register_timing_hw_command("set_timestamp", &TimingHardwareManagerPDII::set_timestamp);
96 0 : register_timing_hw_command("set_endpoint_delay", &TimingHardwareManagerPDII::set_endpoint_delay);
97 0 : register_timing_hw_command("send_fl_command", &TimingHardwareManagerPDII::send_fl_cmd);
98 0 : register_timing_hw_command("master_endpoint_scan", &TimingHardwareManagerPDII::master_endpoint_scan);
99 0 : }
100 :
101 : void
102 0 : TimingHardwareManagerPDII::register_endpoint_hw_commands_for_design()
103 : {
104 0 : register_timing_hw_command("endpoint_enable", &TimingHardwareManagerPDII::endpoint_enable);
105 0 : register_timing_hw_command("endpoint_disable", &TimingHardwareManagerPDII::endpoint_disable);
106 0 : register_timing_hw_command("endpoint_reset", &TimingHardwareManagerPDII::endpoint_reset);
107 0 : }
108 :
109 : void
110 0 : TimingHardwareManagerPDII::register_hsi_hw_commands_for_design()
111 : {
112 0 : register_timing_hw_command("hsi_reset", &TimingHardwareManagerPDII::hsi_reset);
113 0 : register_timing_hw_command("hsi_configure", &TimingHardwareManagerPDII::hsi_configure);
114 0 : register_timing_hw_command("hsi_start", &TimingHardwareManagerPDII::hsi_start);
115 0 : register_timing_hw_command("hsi_stop", &TimingHardwareManagerPDII::hsi_stop);
116 0 : register_timing_hw_command("hsi_print_status", &TimingHardwareManagerPDII::hsi_print_status);
117 0 : }
118 :
119 : // void
120 : // TimingHardwareManagerPDII::get_info(opmonlib::InfoCollector& ci, int level)
121 : // {
122 :
123 : // // send counters internal to the module
124 : // timinghardwaremanagerpdiinfo::Info module_info;
125 : // module_info.received_hw_commands_counter = m_received_hw_commands_counter.load();
126 : // module_info.accepted_hw_commands_counter = m_accepted_hw_commands_counter.load();
127 : // module_info.rejected_hw_commands_counter = m_rejected_hw_commands_counter.load();
128 : // module_info.failed_hw_commands_counter = m_failed_hw_commands_counter.load();
129 :
130 : // ci.add(module_info);
131 :
132 : // // the hardware device data
133 : // for (auto it = m_info_gatherers.begin(); it != m_info_gatherers.end(); ++it) {
134 : // // master info
135 : // if (m_monitored_device_name_master.find(it->second.get()->get_device_name()) != std::string::npos) {
136 : // if (it->second.get()->get_op_mon_level() <= level) {
137 : // it->second.get()->add_info_to_collector("master", ci);
138 : // }
139 : // }
140 :
141 : // for (uint i = 0; i < m_monitored_device_names_fanout.size(); ++i) {
142 : // std::string fanout_device_name = m_monitored_device_names_fanout.at(i);
143 : // if (fanout_device_name.find(it->second.get()->get_device_name()) != std::string::npos) {
144 : // if (it->second.get()->get_op_mon_level() <= level) {
145 : // it->second.get()->add_info_to_collector("fanout_" + std::to_string(i), ci);
146 : // }
147 : // }
148 : // }
149 :
150 : // if (m_monitored_device_name_endpoint.find(it->second.get()->get_device_name()) != std::string::npos) {
151 : // if (it->second.get()->get_op_mon_level() <= level) {
152 : // it->second.get()->add_info_to_collector("endpoint", ci);
153 : // }
154 : // }
155 :
156 : // if (m_monitored_device_name_hsi.find(it->second.get()->get_device_name()) != std::string::npos) {
157 : // if (it->second.get()->get_op_mon_level() <= level) {
158 : // it->second.get()->add_info_to_collector("hsi", ci);
159 : // }
160 : // }
161 : // }
162 : // }
163 :
164 : } // namespace timinglibs
165 : } // namespace dunedaq
166 :
167 0 : DEFINE_DUNE_DAQ_MODULE(dunedaq::timinglibs::TimingHardwareManagerPDII)
168 :
169 : // Local Variables:
170 : // c-basic-offset: 2
171 : // End:
|
