driver.hpp

Go to the documentation of this file.

#ifndef LELY_COCPP_DRIVER_HPP_
#define LELY_COCPP_DRIVER_HPP_

#include <lely/aio/loop.hpp>
#include <lely/coapp/master.hpp>

namespace lely {

namespace canopen {

class DriverBase {
 public:
  using CanState = BasicMaster::CanState;
  using CanError = BasicMaster::CanError;

  using time_point = BasicMaster::time_point;

  DriverBase() = default;

  DriverBase(const DriverBase&) = delete;

  DriverBase& operator=(const DriverBase&) = delete;

  virtual ~DriverBase() = default;

  virtual aio::ExecutorBase GetExecutor() const noexcept = 0;

  virtual uint8_t netid() const noexcept = 0;

  virtual uint8_t id() const noexcept = 0;

  virtual void OnCanState(CanState new_state, CanState old_state) noexcept = 0;

  virtual void OnCanError(CanError error) noexcept = 0;

  virtual void OnCommand(NmtCommand cs) noexcept = 0;

  virtual void OnNodeGuarding(bool occurred) noexcept = 0;

  virtual void OnHeartbeat(bool occurred) noexcept = 0;

  virtual void OnState(NmtState st) noexcept = 0;

  virtual void OnBoot(NmtState st, char es,
                      const ::std::string& what) noexcept = 0;

  virtual void OnConfig(
      ::std::function<void(::std::error_code ec)> res) noexcept = 0;

  virtual void OnRpdo(int num, ::std::error_code ec, const void* p,
                      ::std::size_t n) noexcept = 0;

  virtual void OnRpdoError(int num, uint16_t eec, uint8_t er) noexcept = 0;

  virtual void OnTpdo(int num, ::std::error_code ec, const void* p,
                      ::std::size_t n) noexcept = 0;

  virtual void OnSync(uint8_t cnt, const Node::time_point& t) noexcept = 0;

  virtual void OnSyncError(uint16_t eec, uint8_t er) noexcept = 0;

  virtual void OnTime(
      const ::std::chrono::system_clock::time_point& abs_time) noexcept = 0;

  virtual void OnEmcy(uint16_t eec, uint8_t er, uint8_t msef[5]) noexcept = 0;
};

class BasicDriver : private DriverBase {
  friend class BasicMaster;

 public:
  using DriverBase::time_point;

  BasicDriver(aio::LoopBase& loop, aio::ExecutorBase& exec, BasicMaster& master,
              uint8_t id);

  virtual ~BasicDriver();

  aio::LoopBase
  GetLoop() const noexcept {
    return loop_;
  }

  aio::ExecutorBase
  GetExecutor() const noexcept final override {
    return exec_;
  }

  uint8_t netid() const noexcept final override;

  uint8_t
  id() const noexcept final override {
    return id_;
  }

  void
  Error() {
    master.Error(id());
  }

  template <class T, class F>
  void
  SubmitRead(uint16_t idx, uint8_t subidx, F&& con) {
    auto exec = GetExecutor();
    master.SubmitRead<T>(id(), idx, subidx, exec, ::std::forward<F>(con));
  }

  template <class T, class F>
  void
  SubmitRead(uint16_t idx, uint8_t subidx, F&& con, ::std::error_code& ec) {
    auto exec = GetExecutor();
    master.SubmitRead<T>(id(), idx, subidx, exec, ::std::forward<F>(con), ec);
  }

  template <class T, class F>
  void
  SubmitRead(uint16_t idx, uint8_t subidx, F&& con,
             const Sdo::duration& timeout) {
    auto exec = GetExecutor();
    master.SubmitRead<T>(id(), idx, subidx, exec, ::std::forward<F>(con),
                         timeout);
  }

  template <class T, class F>
  void
  SubmitRead(uint16_t idx, uint8_t subidx, F&& con,
             const Sdo::duration& timeout, ::std::error_code& ec) {
    auto exec = GetExecutor();
    master.SubmitRead<T>(id(), idx, subidx, exec, ::std::forward<F>(con),
                         timeout, ec);
  }

  template <class T, class F>
  void
  SubmitWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con) {
    auto exec = GetExecutor();
    master.SubmitWrite<T>(id(), idx, subidx, ::std::forward<T>(value), exec,
                          ::std::forward<F>(con));
  }

  template <class T, class F>
  void
  SubmitWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con,
              ::std::error_code& ec) {
    auto exec = GetExecutor();
    master.SubmitWrite<T>(id(), idx, subidx, ::std::forward<T>(value), exec,
                          ::std::forward<F>(con), ec);
  }

  template <class T, class F>
  void
  SubmitWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con,
              const Sdo::duration& timeout) {
    auto exec = GetExecutor();
    master.SubmitWrite<T>(id(), idx, subidx, ::std::forward<T>(value), exec,
                          ::std::forward<F>(con), timeout);
  }

  template <class T, class F>
  void
  SubmitWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con,
              const Sdo::duration& timeout, ::std::error_code& ec) {
    auto exec = GetExecutor();
    master.SubmitWrite<T>(id(), idx, subidx, ::std::forward<T>(value), exec,
                          ::std::forward<F>(con), timeout, ec);
  }

  template <class T>
  aio::Future<::std::tuple<::std::error_code, T>>
  AsyncRead(uint16_t idx, uint8_t subidx) {
    auto loop = GetLoop();
    auto exec = GetExecutor();
    return master.AsyncRead<T>(loop, exec, id(), idx, subidx);
  }

  template <class T>
  aio::Future<::std::tuple<::std::error_code, T>>
  AsyncRead(uint16_t idx, uint8_t subidx, const Sdo::duration& timeout) {
    auto loop = GetLoop();
    auto exec = GetExecutor();
    return master.AsyncRead<T>(loop, exec, id(), idx, subidx, timeout);
  }

  template <class T>
  aio::Future<::std::error_code>
  AsyncWrite(uint16_t idx, uint8_t subidx, T&& value) {
    auto loop = GetLoop();
    auto exec = GetExecutor();
    return master.AsyncWrite(loop, exec, id(), idx, subidx,
                             ::std::forward<T>(value));
  }

  template <class T>
  aio::Future<::std::error_code>
  AsyncWrite(uint16_t idx, uint8_t subidx, T&& value,
             const Sdo::duration& timeout) {
    auto loop = GetLoop();
    auto exec = GetExecutor();
    return master.AsyncWrite(loop, exec, id(), idx, subidx,
                             ::std::forward<T>(value), timeout);
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx) {
    ::std::error_code ec;
    auto r = RunRead<T>(idx, subidx, ec);
    if (ec) throw SdoError(netid(), id(), idx, subidx, ec, "RunRead");
    return r;
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx, ::std::error_code& ec) {
    T value{};
    auto future = AsyncRead<T>(idx, subidx);
    if (future) {
      auto t = future.Get();
      ec = ::std::get<0>(t);
      value = ::std::move(::std::get<1>(t));
    } else {
      ec = SdoErrc::NO_SDO;
    }
    return value;
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx, const Sdo::duration& timeout) {
    ::std::error_code ec;
    auto r = RunRead<T>(idx, subidx, timeout, ec);
    if (ec) throw SdoError(netid(), id(), idx, subidx, ec, "RunRead");
    return r;
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx, const Sdo::duration& timeout,
          ::std::error_code& ec) {
    T value{};
    auto future = AsyncRead<T>(idx, subidx, timeout);
    if (future) {
      auto t = future.Get();
      ec = ::std::get<0>(t);
      value = ::std::move(::std::get<1>(t));
    } else {
      ec = SdoErrc::NO_SDO;
    }
    return value;
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value) {
    ::std::error_code ec;
    RunWrite(idx, subidx, ::std::forward<T>(value), ec);
    if (ec) throw SdoError(netid(), id(), idx, subidx, ec, "RunWrite");
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value, ::std::error_code& ec) {
    auto future = AsyncWrite(idx, subidx, ::std::forward<T>(value));
    ec = future ? future.Get() : SdoErrc::NO_SDO;
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value,
           const Sdo::duration& timeout) {
    ::std::error_code ec;
    RunWrite(idx, subidx, ::std::forward<T>(value), timeout, ec);
    if (ec) throw SdoError(netid(), id(), idx, subidx, ec, "RunWrite");
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value,
           const Sdo::duration& timeout, ::std::error_code& ec) {
    auto future = AsyncWrite(idx, subidx, ::std::forward<T>(value), timeout);
    ec = future ? future.Get() : SdoErrc::NO_SDO;
  }

  BasicMaster& master;

  template <class F>
  void
  Post(F&& f) {
    auto* op = new aio::TaskWrapper([=](::std::error_code ec) {
      if (!ec) f();
    });
    GetExecutor().Post(*op);
  }

 private:
  void
  OnCanState(CanState /*new_state*/, CanState /*old_state*/) noexcept override {
  }

  void
  OnCanError(CanError /*error*/) noexcept override {}

  void
  OnCommand(NmtCommand /*cs*/) noexcept override {}

  void
  OnNodeGuarding(bool /*occurred*/) noexcept override {}

  void
  OnHeartbeat(bool /*occurred*/) noexcept override {}

  void
  OnState(NmtState /*st*/) noexcept override {}

  void
  OnBoot(NmtState /*st*/, char /*es*/,
         const ::std::string& /*what*/) noexcept override {}

  void
  OnConfig(::std::function<void(::std::error_code ec)> res) noexcept override {
    res(::std::error_code());
  }

  void
  OnRpdo(int /*num*/, ::std::error_code /*ec*/, const void* /*p*/,
         ::std::size_t /*n*/) noexcept override {}

  void
  OnRpdoError(int /*num*/, uint16_t /*eec*/, uint8_t /*er*/) noexcept override {
  }

  void
  OnTpdo(int /*num*/, ::std::error_code /*ec*/, const void* /*p*/,
         ::std::size_t /*n*/) noexcept override {}

  void
  OnSync(uint8_t /*cnt*/, const time_point& /*t*/) noexcept override {}

  void
  OnSyncError(uint16_t /*eec*/, uint8_t /*er*/) noexcept override {}

  void
  OnTime(const ::std::chrono::system_clock::
             time_point& /*abs_time*/) noexcept override {}

  void
  OnEmcy(uint16_t /*eec*/, uint8_t /*er*/,
         uint8_t /*msef*/[5]) noexcept override {}

  aio_loop_t* loop_{nullptr};
  aio_exec_t* exec_{nullptr};
  uint8_t id_{0xff};
};

namespace detail {

class LoopDriverBase {
 protected:
  aio::Loop loop{};
  aio::Executor exec{loop};
};

}  // namespace detail

class LoopDriver : private detail::LoopDriverBase, public BasicDriver {
 public:
  LoopDriver(BasicMaster& master, uint8_t id);
  ~LoopDriver();

 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};

}  // namespace canopen

}  // namespace lely

#endif  // LELY_COCPP_DRIVER_HPP_