BusManager.hpp

Go to the documentation of this file.

#pragma once
 
// std
#include <memory>
#include <mutex>
#include <bota_node/bota_node.hpp>
#include <rokubimini/Rokubimini.hpp>
#include <utility>
 
namespace rokubimini
{
class RokubiminiBusManager : public bota_node::Node
{
public:
  using DiagnosticsUpdaterPtr = std::shared_ptr<diagnostic_updater::Updater>;
  using NodeHandlePtr = std::shared_ptr<ros::NodeHandle>;
  RokubiminiBusManager() = delete;
 
  explicit RokubiminiBusManager(const std::string& busName, NodeHandlePtr nh)
    : bota_node::Node(nh), name_(busName), nh_(std::move(nh))
  {
    rokubiminis_.clear();
  };
 
  explicit RokubiminiBusManager(const NodeHandlePtr& nh) : bota_node::Node(nh), nh_(nh)
  {
    rokubiminis_.clear();
  };
 
  ~RokubiminiBusManager() override = default;
 
  virtual bool addRokubiminiToBus(const std::shared_ptr<Rokubimini>& rokubimini) const;
 
  virtual bool startupCommunication()
  {
    return true;
  };
 
  bool init() override;
 
  void cleanup() override;
 
  virtual bool startup();
 
  virtual bool update(const bota_worker::WorkerEvent& event);
 
  virtual void shutdown();
 
  virtual void shutdownBus(){ /* do nothing */ };
 
  virtual void writeToBus(){ /* do nothing */ };
 
  virtual void readBus(){ /* do nothing */ };
 
  virtual void setConfigMode(){ /* do nothing */ };
 
  virtual void setRunMode(){ /* do nothing */ };
 
  virtual bool createRokubimini(const std::string& rokubiminiName) = 0;
 
  virtual bool createRokubiminisFromParamServer();
 
  virtual bool loadBusParameters() = 0;
 
  virtual bool load();
 
  inline std::string getName() const
  {
    return name_;
  }
 
  void setNodeHandle(const NodeHandlePtr& nh)
  {
    nh_ = nh;
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->setNodeHandle(nh);
    }
  }
 
  inline bool hasRokubimini(const std::string& name)
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      if (rokubimini->getName() == name)
      {
        return true;
      }
    }
    return false;
  }
 
  inline std::shared_ptr<Rokubimini> getRokubimini(const std::string& name) const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      if (rokubimini->getName() == name)
      {
        return rokubimini;
      }
    }
    return nullptr;
  }
 
  inline std::vector<std::shared_ptr<Rokubimini>> getRokubiminis() const
  {
    return rokubiminis_;
  }
 
  inline void createRokubiminiRosPublishers() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->createRosPublishers();
    }
  }
 
  inline void createRokubiminiRosServices() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->createRosServices();
    }
  }
 
  inline void createRokubiminiRosDiagnostics() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->createRosDiagnostics();
    }
  }
  inline void publishRosMessages() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->publishRosMessages();
    }
  }
  virtual void publishBusManagerRosDiagnostics() = 0;
 
  inline void publishRokubiminiRosDiagnostics() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->publishRosDiagnostics();
    }
  }
  inline void startupWithoutCommunication() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->startupWithoutCommunication();
    }
  }
 
  inline void shutdownWithoutCommunication() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->shutdownWithoutCommunication();
    }
  }
 
  inline void shutdownWithCommunication() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->shutdownWithCommunication();
    }
  }
 
  inline void startupWithCommunication() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->startupWithCommunication();
    }
  }
 
  inline void updateProcessReading() const
  {
    for (const auto& rokubimini : rokubiminis_)
    {
      rokubimini->updateProcessReading();
    }
  }
 
  virtual double loadTimeStep() = 0;
 
protected:
  std::vector<std::shared_ptr<Rokubimini>> rokubiminis_;
 
  std::string name_;
  NodeHandlePtr nh_;
 
  std::atomic<bool> isRunning_{ false };
};
 
}  // namespace rokubimini