monitorThread.hpp

Go to the documentation of this file.

 
#ifndef IFW_CCF_CTL_MONITOR_THREAD_HPP_
#define IFW_CCF_CTL_MONITOR_THREAD_HPP_
 
#include <boost/exception/diagnostic_information.hpp>
 
#include <ifw/ccf/common/base.hpp>
#include <ifw/ccf/common/utilities.hpp>
 
 
namespace ifw::ccf::control {
 
  constexpr auto CFG_KEY_ADPT_ACTIVE             = "mon_adpt_active";
  constexpr auto CFG_KEY_ADPT_DISABLE_DURING_ACQ = "mon_adpt_disable_during_acq";
  constexpr auto CFG_KEY_ADPT_PERIOD             = "mon_adpt_period";
  constexpr auto CFG_KEY_DISABLE_DURING_ACQ      = "disable_during_acq";
  constexpr auto CFG_KEY_NODES_LIST_DEF          = "nodes_list";
  constexpr auto CFG_KEY_NODES                   = "nodes";
  constexpr auto CFG_KEY_OLDB_NODE               = "oldb_node";
  constexpr auto CFG_KEY_META_KEY                = "meta_key";
 
  struct TelemetryNode {
        std::string  m_name;
        std::string  m_oldb_node;
        std::string  m_metadata_key;
  };
 
  struct TelemetryCacheEntry {
    TelemetryNode                 node;
    ifw::core::utils::param::Parameter par;
  };
 
  class MonitorThread: public ifw::ccf::mptk::Thread {
    public:
      MonitorThread(const std::string& thread_name,
                    ifw::ccf::mptk::MessageBus& message_bus,
                    const double period = 0.1);
 
      virtual ~MonitorThread();
 
      void Initialise();
 
      virtual void UserLogic();
 
    private:
      //void HandleTelemetry(const double time_now);
      void CollectData();
      void ComputePublishStatistics();
      void CheckMessageBus();
      void HandleNewSetup(ifw::ccf::Status status,
                          std::string& diagnostics);
 
      void ComputeStatistics(const std::vector<double>& data_set,
                             uint16_t& samples_in_set,
                             double& mean,
                             double& min,
                             double& max,
                             double& stddev,
                             double& jitter,
                             const double theoretic_periodicty = INT_MIN);
 
      std::list<std::string>                              m_thread_names;
      std::map<std::string, ifw::ccf::common::FrameStatistics> m_thr_name_to_frame_stat;
      std::map<std::string, double>                       m_thread_drift;
      std::map<uint64_t, double>                          m_thread_drift_window;
      uint64_t                                            m_drift_count;
      double                                              m_mon_last_rec_wait_clean_up;
 
      // Monitor Adapter parameters.
      bool                                  m_mon_adpt_active;
      bool                                  m_mon_adpt_disable_during_acq;
      double                                m_mon_adpt_period;
 
      double                                m_time_last_mon_adpt_exec;
 
      // bool                                  m_tel_enabled{false};
      // double                                m_tel_period{0};
      // bool                                  m_disable_during_acq{true};
      // std::map<std::string, ifw::ccf::control::TelemetryNode>  m_tel_nodes;
      // std::vector<std::string>              m_tel_names;
      // double                                m_time_last_tel_sampling_exec{0};
  };
 
}
 
#endif // IFW_CCF_CTL_MONITOR_THREAD_HPP_