monitor_machine.h

Go to the documentation of this file.

#pragma once
 
#include "core/containers/thread_safe_queue.h"
#include "ethernet_slave.h"
#include "global.h"
#include "machine.h"
#include "parameter_value_refresher.h"
#include "virtual_device.h"
#include "virtual_device_manager.h"
 
class VirtualParameter;
namespace ctpl {
class thread_pool;
}
 
class MonitorMachine : public Machine {
  friend class CommandWorker;
 
 public:
  MonitorMachine(VirtualDeviceManager& vdm, ctpl::thread_pool& thread_pool,
                 Notifier& notifier,
                 mm::core::containers::ThreadSafeQueue<OutgoingMachineMessage>&
                     outgoing_machine_message_queue);
  ~MonitorMachine() override;
 
  void execute(uint64_t pending_signals) override;
  void abort_all_client_requests();
  void abort_client_requests(const std::string& connection_id) override;
  void abort_client_requests_by_topic(const std::string& topic);
  void abort_client_requests_by_device_address(uint32_t device_address);
  bool done() override;
 
  inline mm::comm::spoe::Device* get_ethernet_device(uint32_t device_address) {
    if (g_master_type != MasterType::kSpoe) {
      return nullptr;
    }
 
    auto device = vdm_.get_device(device_address);
    auto slave = dynamic_cast<EthernetSlave*>(device);
 
    if (slave == nullptr) {
      return nullptr;
    }
 
    return &slave->getDevice();
  }
 
 private:
  struct Monitoring {
    std::string connection_id_;
    uint32_t device_address_;
    std::string topic_;
    uint32_t interval_;
    std::vector<VirtualParameter*> parameters_;
    VirtualParameter* timestamp_parameter_;
    uint32_t stale_counter_ = 0;
 
    Monitoring(const std::string& connection_id, uint32_t device_address,
               const std::string& topic, uint32_t interval,
               std::vector<VirtualParameter*>& parameters,
               VirtualParameter* timestamp_parameter)
        : connection_id_(connection_id),
          device_address_(device_address),
          topic_(topic),
          interval_(interval),
          parameters_(parameters),
          timestamp_parameter_(timestamp_parameter) {}
  };
 
  uint64_t signal_counter_ = 0;
 
  // <request_id, monitoring>
  std::map<std::string, struct Monitoring> monitoring_map_;
 
  ParameterValueRefresher od_entry_value_refresher_;
 
  void send_status(
      const IncomingMachineMessage& incoming_machine_message,
      motionmaster::MotionMasterMessage::MotionMasterMessage::Status* status);
};