Manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <mutex>
#include <unordered_map>
#include <bota_worker/Worker.hpp>
 
#include <rokubimini/setup/Setup.hpp>
#include <rokubimini/setup/Rokubimini.hpp>
 
#include <rokubimini/Rokubimini.hpp>
#include <rokubimini_bus_manager/BusManager.hpp>
using NodeHandlePtr = std::shared_ptr<ros::NodeHandle>;
namespace rokubimini
{
class BaseManager
{
public:
  BaseManager(){};
 
  virtual ~BaseManager() = default;
 
  virtual bool loadSetup() = 0;
 
  virtual bool startup() = 0;
 
  virtual bool update() = 0;
 
  virtual void shutdown() = 0;
};
 
class RokubiminiManager : public BaseManager
{
public:
  RokubiminiManager() = delete;
 
  RokubiminiManager(const bool standalone, const bool installSignalHandler, const double timeStep = 0.01,
                    const NodeHandlePtr nh = nullptr);
 
  ~RokubiminiManager() override = default;
 
  std::shared_ptr<Rokubimini> getRokubimini(const std::string& name) const;
 
  std::vector<std::shared_ptr<Rokubimini>> getRokubiminis() const;
 
  bool loadSetup() override;
 
  bool startup() override;
 
  bool update() override;
 
  void shutdown() override;
 
  void updateProcessReadings();
 
  void updateCommunicationManagerWriteMessages();
 
  void updateCommunicationManagerReadMessages();
 
  void setNodeHandle(const std::shared_ptr<ros::NodeHandle>& nh) const;
 
  void createRokubiminiRosPublishers() const;
 
  void createRokubiminiRosServices() const;
 
  void publishRosMessages() const;
 
protected:
  bool addRokubimini(const std::shared_ptr<Rokubimini>& rokubimini);
 
  bool rokubiminiExists(const std::string& name) const;
 
  bool updateWorkerCb(const bota_worker::WorkerEvent& event);
 
  void requestShutdown();
 
  bool createRokubiminisFromSetup(const rokubimini::setup::SetupPtr& setup);
 
  bool loadBusManagersSetup();
 
  bool createAndConfigureRokubimini(const std::shared_ptr<rokubimini::setup::Rokubimini>& rokubiminiSetup);
 
  std::shared_ptr<bota_worker::Worker> updateWorker_{ nullptr };
 
  std::atomic<bool> isRunning_{ false };
 
  std::atomic<bool> shutdownRequested_{ false };
 
  std::vector<std::shared_ptr<Rokubimini>> rokubiminis_;
  // std::unordered_map<std::unique_ptr<RokubiminiBusManager>, std::vector<std::unique_ptr<Rokubimini>>>
  // mapOfRokubiminisToBusManagers_;
 
  std::vector<std::unique_ptr<RokubiminiBusManager>> busManagers_;
 
  void handleSignal(const int signum);
 
private:
  bool standalone_{ true };
  double timeStep_{ 0.0 };
  std::string configurationFile_{ "" };
  NodeHandlePtr nh_;
};
}  // namespace rokubimini