driver.hpp

Go to the documentation of this file.

 
#ifndef LELY_COAPP_DRIVER_HPP_
#define LELY_COAPP_DRIVER_HPP_
 
#include <lely/coapp/master.hpp>
 
#include <map>
#include <string>
#include <utility>
 
namespace lely {
 
namespace canopen {

class DriverBase {
 public:
  using time_point = BasicMaster::time_point;
 
  DriverBase() = default;
 
  DriverBase(const DriverBase&) = delete;
  DriverBase& operator=(const DriverBase&) = delete;
 
  virtual ~DriverBase() = default;

  virtual ev::Executor GetExecutor() const noexcept = 0;

  virtual uint8_t netid() const noexcept = 0;

  virtual uint8_t id() const noexcept = 0;

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

  virtual void OnCanError(io::CanError error) noexcept = 0;
 
  /*
   * The function invoked when a value is successfully written to an RPDO-mapped
   * object in the local object dictionary by a Receive-PDO (or SDO download)
   * request.
   *
   * @param idx    the remote object index.
   * @param subidx the remote object sub-index.
   */
  virtual void OnRpdoWrite(uint16_t idx, uint8_t subidx) noexcept = 0;

  virtual void OnCommand(NmtCommand cs) noexcept = 0;

  virtual void OnHeartbeat(bool occurred) noexcept = 0;

  virtual void OnState(NmtState st) noexcept = 0;

  virtual void OnSync(uint8_t cnt, const 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;

  virtual void OnNodeGuarding(bool occurred) 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 OnDeconfig(
      ::std::function<void(::std::error_code ec)> res) noexcept = 0;
};

class LogicalDriverBase : public DriverBase {
 public:
  virtual int Number() const noexcept = 0;

  virtual SdoFuture<void> AsyncConfig() = 0;

  virtual SdoFuture<void> AsyncDeconfig() = 0;
};

class BasicDriver : DriverBase,
                    protected ::std::map<uint8_t, LogicalDriverBase*> {
  friend class LoopDriver;
 
 public:
  using DriverBase::time_point;
  using duration = BasicMaster::duration;
  using TpdoEventMutex = BasicMaster::TpdoEventMutex;

  explicit BasicDriver(ev_exec_t* exec, BasicMaster& master, uint8_t id);

  explicit BasicDriver(BasicMaster& master, uint8_t id)
      : BasicDriver(nullptr, master, id) {}
 
  virtual ~BasicDriver();
 
  ev::Executor
  GetExecutor() const noexcept final {
    return ev::Executor(exec_);
  }
 
  uint8_t
  netid() const noexcept final {
    return master.netid();
  }
 
  uint8_t
  id() const noexcept final {
    return id_;
  }

  void
  ConfigHeartbeat(const ::std::chrono::milliseconds& ms,
                  ::std::error_code& ec) {
    master.ConfigHeartbeat(id(), ms, ec);
  }

  void
  ConfigHeartbeat(const ::std::chrono::milliseconds& ms) {
    master.ConfigHeartbeat(id(), ms);
  }

  bool
  Boot() {
    return master.Boot(id());
  }

  bool
  IsReady() const {
    return master.IsReady(id());
  }

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

  template <class T>
  void
  DamMpdoEvent(int num, uint16_t idx, uint8_t subidx, T value) {
    master.DamMpdoEvent(num, id(), idx, subidx, value);
  }

  template <class F>
  void
  SubmitWait(const time_point& t, F&& f) {
    return master.SubmitWait(t, GetExecutor(), ::std::forward<F>(f));
  }

  template <class F>
  void
  SubmitWait(const duration& d, F&& f) {
    return master.SubmitWait(d, GetExecutor(), ::std::forward<F>(f));
  }

  SdoFuture<void>
  AsyncWait(const time_point& t) {
    return master.AsyncWait(GetExecutor(), t);
  }

  SdoFuture<void>
  AsyncWait(const duration& d) {
    return master.AsyncWait(GetExecutor(), d);
  }

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

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

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

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

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

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

  template <class T, class F>
  void
  SubmitBlockRead(uint16_t idx, uint8_t subidx, F&& con,
                  const ::std::chrono::milliseconds& timeout) {
    master.SubmitBlockRead<T>(GetExecutor(), id(), idx, subidx,
                              ::std::forward<F>(con), timeout);
  }

  template <class T, class F>
  void
  SubmitBlockRead(uint16_t idx, uint8_t subidx, F&& con,
                  const ::std::chrono::milliseconds& timeout,
                  ::std::error_code& ec) {
    master.SubmitBlockRead<T>(GetExecutor(), id(), idx, subidx,
                              ::std::forward<F>(con), timeout, ec);
  }

  template <class T, class F>
  void
  SubmitWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con) {
    master.SubmitWrite(GetExecutor(), id(), idx, subidx,
                       ::std::forward<T>(value), ::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) {
    master.SubmitWrite(GetExecutor(), id(), idx, subidx,
                       ::std::forward<T>(value), ::std::forward<F>(con), ec);
  }

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

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

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

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

  template <class T, class F>
  void
  SubmitBlockWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con,
                   const ::std::chrono::milliseconds& timeout) {
    master.SubmitBlockWrite(GetExecutor(), id(), idx, subidx,
                            ::std::forward<T>(value), ::std::forward<F>(con),
                            timeout);
  }

  template <class T, class F>
  void
  SubmitBlockWrite(uint16_t idx, uint8_t subidx, T&& value, F&& con,
                   const ::std::chrono::milliseconds& timeout,
                   ::std::error_code& ec) {
    master.SubmitBlockWrite(GetExecutor(), id(), idx, subidx,
                            ::std::forward<T>(value), ::std::forward<F>(con),
                            timeout, ec);
  }

  template <class F>
  void
  SubmitWriteDcf(const uint8_t* begin, const uint8_t* end, F&& con) {
    master.SubmitWriteDcf(GetExecutor(), id(), begin, end,
                          ::std::forward<F>(con));
  }

  template <class F>
  void
  SubmitWriteDcf(const uint8_t* begin, const uint8_t* end, F&& con,
                 ::std::error_code& ec) {
    master.SubmitWriteDcf(GetExecutor(), id(), begin, end,
                          ::std::forward<F>(con), ec);
  }

  template <class F>
  void
  SubmitWriteDcf(const uint8_t* begin, const uint8_t* end, F&& con,
                 const ::std::chrono::milliseconds& timeout) {
    master.SubmitWriteDcf(GetExecutor(), id(), begin, end,
                          ::std::forward<F>(con), timeout);
  }

  template <class F>
  void
  SubmitWriteDcf(const uint8_t* begin, const uint8_t* end, F&& con,
                 const ::std::chrono::milliseconds& timeout,
                 ::std::error_code& ec) {
    master.SubmitWriteDcf(GetExecutor(), id(), begin, end,
                          ::std::forward<F>(con), timeout, ec);
  }

  template <class F>
  void
  SubmitWriteDcf(const char* path, F&& con) {
    master.SubmitWriteDcf(GetExecutor(), id(), path, ::std::forward<F>(con));
  }

  template <class F>
  void
  SubmitWriteDcf(const char* path, F&& con, ::std::error_code& ec) {
    master.SubmitWriteDcf(GetExecutor(), id(), path, ::std::forward<F>(con),
                          ec);
  }

  template <class F>
  void
  SubmitWriteDcf(const char* path, F&& con,
                 const ::std::chrono::milliseconds& timeout) {
    master.SubmitWriteDcf(GetExecutor(), id(), path, ::std::forward<F>(con),
                          timeout);
  }

  template <class F>
  void
  SubmitWriteDcf(const char* path, F&& con,
                 const ::std::chrono::milliseconds& timeout,
                 ::std::error_code& ec) {
    master.SubmitWriteDcf(GetExecutor(), id(), path, ::std::forward<F>(con),
                          timeout, ec);
  }

  template <class T>
  SdoFuture<T>
  AsyncRead(uint16_t idx, uint8_t subidx) {
    return master.AsyncRead<T>(GetExecutor(), id(), idx, subidx);
  }

  template <class T>
  SdoFuture<T>
  AsyncRead(uint16_t idx, uint8_t subidx,
            const ::std::chrono::milliseconds& timeout) {
    return master.AsyncRead<T>(GetExecutor(), id(), idx, subidx, timeout);
  }

  template <class T>
  SdoFuture<T>
  AsyncBlockRead(uint16_t idx, uint8_t subidx) {
    return master.AsyncBlockRead<T>(GetExecutor(), id(), idx, subidx);
  }

  template <class T>
  SdoFuture<T>
  AsyncBlockRead(uint16_t idx, uint8_t subidx,
                 const ::std::chrono::milliseconds& timeout) {
    return master.AsyncBlockRead<T>(GetExecutor(), id(), idx, subidx, timeout);
  }

  template <class T>
  SdoFuture<void>
  AsyncWrite(uint16_t idx, uint8_t subidx, T&& value) {
    return master.AsyncWrite(GetExecutor(), id(), idx, subidx,
                             ::std::forward<T>(value));
  }

  template <class T>
  SdoFuture<void>
  AsyncWrite(uint16_t idx, uint8_t subidx, T&& value,
             const ::std::chrono::milliseconds& timeout) {
    return master.AsyncWrite(GetExecutor(), id(), idx, subidx,
                             ::std::forward<T>(value), timeout);
  }

  template <class T>
  SdoFuture<void>
  AsyncBlockWrite(uint16_t idx, uint8_t subidx, T&& value) {
    return master.AsyncBlockWrite(GetExecutor(), id(), idx, subidx,
                                  ::std::forward<T>(value));
  }

  template <class T>
  SdoFuture<void>
  AsyncBlockWrite(uint16_t idx, uint8_t subidx, T&& value,
                  const ::std::chrono::milliseconds& timeout) {
    return master.AsyncBlockWrite(GetExecutor(), id(), idx, subidx,
                                  ::std::forward<T>(value), timeout);
  }

  SdoFuture<void>
  AsyncWriteDcf(const uint8_t* begin, const uint8_t* end) {
    return master.AsyncWriteDcf(GetExecutor(), id(), begin, end);
  }

  SdoFuture<void>
  AsyncWriteDcf(const uint8_t* begin, const uint8_t* end,
                const ::std::chrono::milliseconds& timeout) {
    return master.AsyncWriteDcf(GetExecutor(), id(), begin, end, timeout);
  }

  SdoFuture<void>
  AsyncWriteDcf(const char* path) {
    return master.AsyncWriteDcf(GetExecutor(), id(), path);
  }

  SdoFuture<void>
  AsyncWriteDcf(const char* path, const ::std::chrono::milliseconds& timeout) {
    return master.AsyncWriteDcf(GetExecutor(), id(), path, timeout);
  }

  void Insert(LogicalDriverBase& driver);

  void Erase(LogicalDriverBase& driver);

  template <class F, class... Args>
  void
  Post(F&& f, Args&&... args) {
    GetExecutor().post(::std::forward<F>(f), ::std::forward<Args>(args)...);
  }

  BasicMaster& master;

  class BasicMaster::RpdoMapped rpdo_mapped;

  class BasicMaster::TpdoMapped tpdo_mapped;

  TpdoEventMutex& tpdo_event_mutex;
 
 protected:
  using MapType = ::std::map<uint8_t, LogicalDriverBase*>;

  void OnCanState(io::CanState new_state,
                  io::CanState old_state) noexcept override;

  void OnCanError(io::CanError error) noexcept override;

  void OnRpdoWrite(uint16_t idx, uint8_t subidx) noexcept override;

  void OnCommand(NmtCommand cs) noexcept override;

  void OnHeartbeat(bool occurred) noexcept override;

  void OnState(NmtState st) 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;

  void OnNodeGuarding(bool occurred) 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;

  void OnDeconfig(
      ::std::function<void(::std::error_code ec)> res) noexcept override;

  SdoFuture<void> AsyncConfig(int num = 0);

  SdoFuture<void> AsyncDeconfig(int num = 0);
 
 private:
  ev_exec_t* exec_{nullptr};
  const uint8_t id_{0xff};
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COAPP_DRIVER_HPP_