master.hpp

Go to the documentation of this file.

 
#ifndef LELY_COCPP_MASTER_HPP_
#define LELY_COCPP_MASTER_HPP_
 
#include <lely/coapp/detail/mutex.hpp>
#include <lely/coapp/node.hpp>
#include <lely/coapp/sdo.hpp>
 
#include <map>
 
namespace lely {
 
namespace canopen {
 
class DriverBase;
 
class BasicMaster : public Node, protected ::std::map<uint8_t, DriverBase*> {
 public:
  class Object;
  class ConstObject;
 
  class SubObject {
    friend class Object;
 
   public:
    SubObject(const SubObject&) = default;
    SubObject(SubObject&&) = default;
 
    SubObject& operator=(const SubObject&) = default;
    SubObject& operator=(SubObject&&) = default;
 
    template <class T>
    SubObject&
    operator=(T&& value) {
      Write(::std::forward<T>(value));
      return *this;
    }
 
    template <class T>
    operator T() const {
      return Read<T>();
    }
 
    template <class T>
    T
    Read() const {
      return master_->Read<T>(idx_, subidx_);
    }
 
    template <class T>
    T
    Read(::std::error_code& ec) const {
      return master_->Read<T>(idx_, subidx_, ec);
    }
 
    template <class T>
    void
    Write(T&& value) {
      master_->Write(idx_, subidx_, ::std::forward<T>(value));
    }
 
    template <class T>
    void
    Write(T&& value, ::std::error_code& ec) {
      master_->Write(idx_, subidx_, ::std::forward<T>(value), ec);
    }
 
    void
    Write(const void* p, ::std::size_t n) {
      master_->Write(idx_, subidx_, p, n);
    }
 
    void
    Write(const void* p, ::std::size_t n, ::std::error_code& ec) {
      master_->Write(idx_, subidx_, p, n, ec);
    }
 
   private:
    SubObject(BasicMaster* master, uint16_t idx, uint8_t subidx)
        : master_(master), idx_(idx), subidx_(subidx) {}
 
    BasicMaster* master_;
    uint16_t idx_;
    uint8_t subidx_;
  };
 
  class ConstSubObject {
    friend class Object;
    friend class ConstObject;
 
   public:
    template <class T>
    operator T() const {
      return Read<T>();
    }
 
    template <class T>
    T
    Read() const {
      return master_->Read<T>(idx_, subidx_);
    }
 
    template <class T>
    T
    Read(::std::error_code& ec) const {
      return master_->Read<T>(idx_, subidx_, ec);
    }
 
   private:
    ConstSubObject(const BasicMaster* master, uint16_t idx, uint8_t subidx)
        : master_(master), idx_(idx), subidx_(subidx) {}
 
    const BasicMaster* master_;
    uint16_t idx_;
    uint8_t subidx_;
  };
 
  class Object {
    friend class BasicMaster;
 
   public:
    SubObject operator[](uint8_t subidx) {
      return SubObject(master_, idx_, subidx);
    }
 
    ConstSubObject operator[](uint8_t subidx) const {
      return ConstSubObject(master_, idx_, subidx);
    }
 
   private:
    Object(BasicMaster* master, uint16_t idx) : master_(master), idx_(idx) {}
 
    BasicMaster* master_;
    uint16_t idx_;
  };
 
  class ConstObject {
    friend class BasicMaster;
 
   public:
    ConstSubObject operator[](uint8_t subidx) const {
      return ConstSubObject(master_, idx_, subidx);
    }
 
   private:
    ConstObject(const BasicMaster* master, uint16_t idx)
        : master_(master), idx_(idx) {}
 
    const BasicMaster* master_;
    uint16_t idx_;
  };
 
  template <class T>
  using ReadSignature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                             ::std::error_code ec, T value);
 
  using WriteSignature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                              ::std::error_code ec);
 
  BasicMaster(aio::TimerBase& timer, aio::CanBusBase& bus,
              const ::std::string& dcf_txt, const ::std::string& dcf_bin = "",
              uint8_t id = 0xff);
 
  virtual ~BasicMaster();
 
  Object operator[](uint16_t idx) { return Object(this, idx); }
 
  ConstObject operator[](uint16_t idx) const { return ConstObject(this, idx); }
 
  void Error(uint8_t id);
 
  /*
   * Generates an EMCY error and triggers the error handling behavior according
   * to object 1029:01 (Error behavior object) in case of a communication error
   * (emergency error code 0x81xx).
   *
   * @param eec  the emergency error code.
   * @param er   the error register.
   * @param msef the manufacturer-specific error code.
   */
  void Error(uint16_t eec, uint8_t er, const uint8_t msef[5] = nullptr);
 
  void RpdoRtr(int num = 0);
 
  void TpdoEvent(int num = 0);
 
  ::std::chrono::milliseconds GetTimeout() const;
 
  void SetTimeout(const ::std::chrono::milliseconds& timeout);
 
  template <class T>
  void
  SubmitRead(uint8_t id, Sdo::UploadRequest<T>& req) {
    ::std::error_code ec;
    SubmitRead<T>(id, req, ec);
    if (ec) throw SdoError(netid(), id, req.idx, req.subidx, ec, "SubmitRead");
  }
 
  template <class T>
  void
  SubmitRead(uint8_t id, Sdo::UploadRequest<T>& req, ::std::error_code& ec) {
    ::std::lock_guard<BasicLockable> lock(*this);
 
    ec.clear();
    auto sdo = GetSdo(id);
    if (sdo) {
      SetTime();
      sdo->SubmitUpload<T>(req);
    } else {
      ec = SdoErrc::NO_SDO;
    }
  }
 
  template <class T, class F>
  void
  SubmitRead(uint8_t id, uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
             F&& con) {
    SubmitRead<T>(id, idx, subidx, exec, ::std::forward<F>(con), GetTimeout());
  }
 
  template <class T, class F>
  void
  SubmitRead(uint8_t id, uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
             F&& con, ::std::error_code& ec) {
    SubmitRead<T>(id, idx, subidx, exec, ::std::forward<F>(con), GetTimeout(),
                  ec);
  }
 
  template <class T, class F>
  void
  SubmitRead(uint8_t id, uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
             F&& con, const Sdo::duration& timeout) {
    ::std::error_code ec;
    SubmitRead<T>(id, idx, subidx, exec, ::std::forward<F>(con), timeout, ec);
    if (ec) throw SdoError(netid(), id, idx, subidx, ec, "SubmitRead");
  }
 
  template <class T, class F>
  void
  SubmitRead(uint8_t id, uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
             F&& con, const Sdo::duration& timeout, ::std::error_code& ec) {
    ::std::lock_guard<BasicLockable> lock(*this);
 
    ec.clear();
    auto sdo = GetSdo(id);
    if (sdo) {
      SetTime();
      if (con) {
        sdo->SubmitUpload<T>(
            idx, subidx, exec,
            [=](uint16_t idx, uint8_t subidx, ::std::error_code ec, T value) {
              con(id, idx, subidx, ec, ::std::move(value));
            },
            timeout);
      } else {
        sdo->SubmitUpload<T>(idx, subidx, exec, nullptr, timeout);
      }
    } else {
      ec = SdoErrc::NO_SDO;
    }
  }
 
  template <class T>
  void
  SubmitWrite(uint8_t id, Sdo::DownloadRequest<T>& req) {
    ::std::error_code ec;
    SubmitWrite<T>(id, req, ec);
    if (ec) throw SdoError(netid(), id, req.idx, req.subidx, ec, "SubmitWrite");
  }
 
  template <class T>
  void
  SubmitWrite(uint8_t id, Sdo::DownloadRequest<T>& req, ::std::error_code& ec) {
    ::std::lock_guard<BasicLockable> lock(*this);
 
    ec.clear();
    auto sdo = GetSdo(id);
    if (sdo) {
      SetTime();
      sdo->SubmitDownload<T>(req);
    } else {
      ec = SdoErrc::NO_SDO;
    }
  }
 
  template <class T, class F>
  void
  SubmitWrite(uint8_t id, uint16_t idx, uint8_t subidx, T&& value,
              aio::ExecutorBase& exec, F&& con) {
    SubmitWrite(id, idx, subidx, ::std::forward<T>(value), exec,
                ::std::forward<F>(con), GetTimeout());
  }
 
  template <class T, class F>
  void
  SubmitWrite(uint8_t id, uint16_t idx, uint8_t subidx, T&& value,
              aio::ExecutorBase& exec, F&& con, ::std::error_code& ec) {
    SubmitWrite(id, idx, subidx, ::std::forward<T>(value), exec,
                ::std::forward<F>(con), GetTimeout(), ec);
  }
 
  template <class T, class F>
  void
  SubmitWrite(uint8_t id, uint16_t idx, uint8_t subidx, T&& value,
              aio::ExecutorBase& exec, F&& con, const Sdo::duration& timeout) {
    ::std::error_code ec;
    SubmitWrite(id, idx, subidx, ::std::forward<T>(value), exec,
                ::std::forward<F>(con), timeout, ec);
    if (ec) throw SdoError(netid(), id, idx, subidx, ec, "SubmitWrite");
  }
 
  template <class T, class F>
  void
  SubmitWrite(uint8_t id, uint16_t idx, uint8_t subidx, T&& value,
              aio::ExecutorBase& exec, F&& con, const Sdo::duration& timeout,
              ::std::error_code& ec) {
    ::std::lock_guard<BasicLockable> lock(*this);
 
    ec.clear();
    auto sdo = GetSdo(id);
    if (sdo) {
      SetTime();
      if (con) {
        sdo->SubmitDownload(
            idx, subidx, ::std::forward<T>(value), exec,
            [=](uint16_t idx, uint8_t subidx, ::std::error_code ec) {
              con(id, idx, subidx, ec);
            },
            timeout);
      } else {
        sdo->SubmitDownload(idx, subidx, ::std::forward<T>(value), exec,
                            nullptr, timeout);
      }
    } else {
      ec = SdoErrc::NO_SDO;
    }
  }
 
  template <class T>
  aio::Future<::std::tuple<::std::error_code, T>>
  AsyncRead(aio::LoopBase& loop, aio::ExecutorBase& exec, uint8_t id,
            uint16_t idx, uint8_t subidx) {
    return AsyncRead<T>(loop, exec, id, idx, subidx, GetTimeout());
  }
 
  template <class T>
  aio::Future<::std::tuple<::std::error_code, T>>
  AsyncRead(aio::LoopBase& loop, aio::ExecutorBase& exec, uint8_t id,
            uint16_t idx, uint8_t subidx, const Sdo::duration& timeout) {
    ::std::lock_guard<BasicLockable> lock(*this);
 
    aio::Future<::std::tuple<::std::error_code, T>> future(nullptr);
    auto sdo = GetSdo(id);
    if (sdo) {
      SetTime();
      future = sdo->AsyncUpload<T>(loop, exec, idx, subidx, timeout);
    }
    return future;
  }
 
  template <class T>
  aio::Future<::std::error_code>
  AsyncWrite(aio::LoopBase& loop, aio::ExecutorBase& exec, uint8_t id,
             uint16_t idx, uint8_t subidx, T&& value) {
    return AsyncWrite(loop, exec, id, idx, subidx, ::std::forward<T>(value),
                      GetTimeout());
  }
 
  template <class T>
  aio::Future<::std::error_code>
  AsyncWrite(aio::LoopBase& loop, aio::ExecutorBase& exec, uint8_t id,
             uint16_t idx, uint8_t subidx, T&& value,
             const Sdo::duration& timeout) {
    ::std::lock_guard<BasicLockable> lock(*this);
 
    aio::Future<::std::error_code> future(nullptr);
    auto sdo = GetSdo(id);
    if (sdo) {
      SetTime();
      future = sdo->AsyncDownload(loop, exec, idx, subidx,
                                  ::std::forward<T>(value), timeout);
    }
    return future;
  }
 
  void Insert(DriverBase& driver);
 
  void Erase(DriverBase& driver);
 
 protected:
  using MapType = ::std::map<uint8_t, DriverBase*>;
 
  void OnCanError(CanError error) noexcept override;
 
  void OnCanState(CanState new_state, CanState old_state) noexcept override;
 
  void OnCommand(NmtCommand cs) noexcept override;
 
  virtual void OnNodeGuarding(uint8_t id, bool occurred) noexcept;
 
  void OnHeartbeat(uint8_t id, bool occurred) noexcept override;
 
  void OnState(uint8_t id, NmtState st) noexcept override;
 
  virtual void OnBoot(uint8_t id, NmtState st, char es,
                      const ::std::string& what) noexcept;
 
  virtual void OnConfig(uint8_t id) noexcept;
 
  void ConfigResult(uint8_t id, ::std::error_code ec) noexcept;
 
  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(uint8_t id, uint16_t eec, uint8_t er,
              uint8_t msef[5]) noexcept override;
 
  Sdo* GetSdo(uint8_t id);
 
  void CancelSdo(uint8_t id = 0);
 
 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};
 
class AsyncMaster : public BasicMaster {
 public:
  using BasicMaster::BasicMaster;
 
 protected:
  void OnCanError(CanError error) noexcept override;
 
  void OnCanState(CanState new_state, CanState old_state) noexcept override;
 
  void OnCommand(NmtCommand cs) noexcept override;
 
  void OnNodeGuarding(uint8_t id, bool occurred) noexcept override;
 
  void OnHeartbeat(uint8_t id, bool occurred) noexcept override;
 
  void OnState(uint8_t id, NmtState st) noexcept override;
 
  void OnBoot(uint8_t id, NmtState st, char es,
              const ::std::string& what) noexcept override;
 
  void OnConfig(uint8_t id) noexcept override;
 
  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(uint8_t id, uint16_t eec, uint8_t er,
              uint8_t msef[5]) noexcept override;
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COCPP_MASTER_HPP_