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