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