sdo.hpp

Go to the documentation of this file.

 
#ifndef LELY_COAPP_SDO_HPP_
#define LELY_COAPP_SDO_HPP_
 
#include <lely/coapp/sdo_error.hpp>
#include <lely/coapp/type_traits.hpp>
#include <lely/ev/future.hpp>
 
#include <chrono>
#include <limits>
#include <memory>
#include <string>
#include <utility>
 
// The CAN network interface from <lely/can/net.h>.
struct __can_net;
 
// The CANopen device from <lely/co/dev.h>.
struct __co_dev;
 
// The CANopen Client-SDO service from <lely/co/csdo.h>.
struct __co_csdo;
 
namespace lely {
 
namespace canopen {

template <class T>
using SdoPromise = ev::Promise<T, ::std::exception_ptr>;

template <class T>
using SdoFuture = ev::Future<T, ::std::exception_ptr>;

inline SdoFuture<void>
make_empty_sdo_future() {
  return ev::make_empty_future<::std::exception_ptr>();
}

template <class T, class V = typename ::std::decay<T>::type>
inline SdoFuture<V>
make_ready_sdo_future(T&& value) {
  return ev::make_ready_future<::std::exception_ptr, V>(
      ::std::forward<T>(value));
}

template <class T>
inline SdoFuture<T>
make_error_sdo_future(uint8_t id, uint16_t idx, uint8_t subidx,
                      ::std::error_code ec) {
  return ev::make_error_future<T>(make_sdo_exception_ptr(id, idx, subidx, ec));
}

template <class T>
inline SdoFuture<T>
make_error_sdo_future(uint8_t id, uint16_t idx, uint8_t subidx,
                      ::std::error_code ec, const ::std::string& what_arg) {
  return ev::make_error_future<T>(
      make_sdo_exception_ptr(id, idx, subidx, ec, what_arg));
}

template <class T>
inline SdoFuture<T>
make_error_sdo_future(uint8_t id, uint16_t idx, uint8_t subidx,
                      ::std::error_code ec, const char* what_arg) {
  return ev::make_error_future<T>(
      make_sdo_exception_ptr(id, idx, subidx, ec, what_arg));
}
 
class Sdo;
 
namespace detail {

inline ::std::chrono::milliseconds
from_sdo_timeout(int timeout) {
  using ::std::chrono::milliseconds;
  return timeout <= 0 ? milliseconds::max() : milliseconds(timeout);
}

template <class Rep, class Period>
inline int
to_sdo_timeout(const ::std::chrono::duration<Rep, Period>& d) {
  using ::std::chrono::duration;
  using ::std::chrono::duration_cast;
  using ::std::chrono::milliseconds;
  // The maximum duration is interpreted as an infinite timeout.
  if (d == duration<Rep, Period>::max()) return 0;
  auto timeout = duration_cast<milliseconds>(d).count();
  // A timeout less than 1 ms is rounded up to keep it finite.
  if (timeout < 1) return 1;
  if (timeout > ::std::numeric_limits<int>::max())
    return ::std::numeric_limits<int>::max();
  return timeout;
}
 
class SdoRequestBase : public ev_task {
  friend class canopen::Sdo;
 
 public:
  SdoRequestBase(ev_exec_t* exec, uint16_t idx_ = 0, uint8_t subidx_ = 0,
                 bool block_ = false,
                 const ::std::chrono::milliseconds& timeout_ = {})
      : ev_task EV_TASK_INIT(exec,
                             [](ev_task* task) noexcept {
                               (*static_cast<SdoRequestBase*>(task))();
                             }),
        idx(idx_),
        subidx(subidx_),
        block(block_),
        timeout(timeout_) {}
 
  SdoRequestBase(const SdoRequestBase&) = delete;
 
  SdoRequestBase& operator=(const SdoRequestBase&) = delete;
 
  virtual ~SdoRequestBase() = default;

  ev::Executor
  GetExecutor() const noexcept {
    return ev::Executor(ev_task::exec);
  }

  uint8_t id{0};
  uint16_t idx{0};
  uint8_t subidx{0};
  bool block{false};
  ::std::chrono::milliseconds timeout;
  ::std::error_code ec;
 
 private:
  virtual void operator()() noexcept = 0;
 
  virtual void OnRequest(void* data) noexcept = 0;
};
 
template <class T>
class SdoDownloadRequestBase : public SdoRequestBase {
 public:
  using SdoRequestBase::SdoRequestBase;
 
  template <class U>
  SdoDownloadRequestBase(ev_exec_t* exec, uint16_t idx, uint8_t subidx,
                         U&& value_, bool block = false,
                         const ::std::chrono::milliseconds& timeout = {})
      : SdoRequestBase(exec, idx, subidx, block, timeout),
        value(::std::forward<U>(value_)) {}

  T value{};
};
 
class SdoDownloadDcfRequestBase : public SdoRequestBase {
 public:
  using SdoRequestBase::SdoRequestBase;
 
  SdoDownloadDcfRequestBase(ev_exec_t* exec, const uint8_t* begin_,
                            const uint8_t* end_,
                            const ::std::chrono::milliseconds& timeout = {})
      : SdoRequestBase(exec, 0, 0, false, timeout), begin(begin_), end(end_) {}
 
  SdoDownloadDcfRequestBase(ev_exec_t* exec, const char* path,
                            const ::std::chrono::milliseconds& timeout = {})
      : SdoRequestBase(exec, 0, 0, false, timeout) {
    Read(path);
  }
 
  virtual ~SdoDownloadDcfRequestBase();

  void Read(const char* path);

  const uint8_t* begin{nullptr};

  const uint8_t* end{nullptr};
 
 private:
  void* dom_{nullptr};
};
 
template <class T>
class SdoUploadRequestBase : public SdoRequestBase {
 public:
  using SdoRequestBase::SdoRequestBase;

  T value{};
};
 
}  // namespace detail

template <class T>
class SdoDownloadRequest : public detail::SdoDownloadRequestBase<T> {
 public:
  using Signature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                         ::std::error_code ec);

  template <class F>
  SdoDownloadRequest(ev_exec_t* exec, F&& con)
      : detail::SdoDownloadRequestBase<T>(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void operator()() noexcept final;
 
  void OnRequest(void* data) noexcept final;
 
  ::std::function<Signature> con_;
};

class SdoDownloadDcfRequest : public detail::SdoDownloadDcfRequestBase {
 public:
  using Signature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                         ::std::error_code ec);

  template <class F>
  SdoDownloadDcfRequest(ev_exec_t* exec, F&& con)
      : detail::SdoDownloadDcfRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void operator()() noexcept final;
 
  void OnRequest(void* data) noexcept final;
 
  ::std::function<Signature> con_;
};

template <class T>
class SdoUploadRequest : public detail::SdoUploadRequestBase<T> {
 public:
  using Signature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                         ::std::error_code ec, T value);

  template <class F>
  SdoUploadRequest(ev_exec_t* exec, F&& con)
      : detail::SdoUploadRequestBase<T>(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void operator()() noexcept final;
 
  void OnRequest(void* data) noexcept final;
 
  ::std::function<Signature> con_;
};
 
namespace detail {
 
template <class T>
class SdoDownloadRequestWrapper : public SdoDownloadRequestBase<T> {
 public:
  using Signature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                         ::std::error_code ec);
 
  template <class U, class F>
  SdoDownloadRequestWrapper(ev_exec_t* exec, uint16_t idx, uint8_t subidx,
                            U&& value, F&& con, bool block,
                            const ::std::chrono::milliseconds& timeout)
      : SdoDownloadRequestBase<T>(exec, idx, subidx, ::std::forward<U>(value),
                                  block, timeout),
        con_(::std::forward<F>(con)) {}
 
 private:
  void operator()() noexcept final;
 
  void OnRequest(void* data) noexcept final;
 
  ::std::function<Signature> con_;
};
 
class SdoDownloadDcfRequestWrapper : public SdoDownloadDcfRequestBase {
 public:
  using Signature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                         ::std::error_code ec);
 
  template <class F>
  SdoDownloadDcfRequestWrapper(ev_exec_t* exec, const uint8_t* begin,
                               const uint8_t* end, F&& con,
                               const ::std::chrono::milliseconds& timeout)
      : SdoDownloadDcfRequestBase(exec, begin, end, timeout),
        con_(::std::forward<F>(con)) {}
 
  template <class F>
  SdoDownloadDcfRequestWrapper(ev_exec_t* exec, const char* path, F&& con,
                               const ::std::chrono::milliseconds& timeout)
      : SdoDownloadDcfRequestBase(exec, path, timeout),
        con_(::std::forward<F>(con)) {}
 
  template <class F>
  SdoDownloadDcfRequestWrapper(ev_exec_t* exec, const ::std::string& path,
                               F&& con,
                               const ::std::chrono::milliseconds& timeout)
      : SdoDownloadDcfRequestBase(exec, path.c_str(), timeout),
        con_(::std::forward<F>(con)) {}
 
 private:
  void operator()() noexcept final;
 
  void OnRequest(void* data) noexcept final;
 
  ::std::function<Signature> con_;
};
 
template <class T>
class SdoUploadRequestWrapper : public SdoUploadRequestBase<T> {
 public:
  using Signature = void(uint8_t id, uint16_t idx, uint8_t subidx,
                         ::std::error_code ec, T value);
 
  template <class F>
  SdoUploadRequestWrapper(ev_exec_t* exec, uint16_t idx, uint8_t subidx,
                          F&& con, bool block,
                          const ::std::chrono::milliseconds& timeout)
      : SdoUploadRequestBase<T>(exec, idx, subidx, block, timeout),
        con_(::std::forward<F>(con)) {}
 
 private:
  void operator()() noexcept final;
 
  void OnRequest(void* data) noexcept final;
 
  ::std::function<Signature> con_;
};
 
}  // namespace detail

template <class T, class U, class F>
inline detail::SdoDownloadRequestWrapper<T>*
make_sdo_download_request(ev_exec_t* exec, uint16_t idx, uint8_t subidx,
                          U&& value, F&& con, bool block = false,
                          const ::std::chrono::milliseconds& timeout = {}) {
  return new detail::SdoDownloadRequestWrapper<T>(
      exec, idx, subidx, ::std::forward<U>(value), ::std::forward<F>(con),
      block, timeout);
}

template <class F>
inline detail::SdoDownloadDcfRequestWrapper*
make_sdo_download_dcf_request(ev_exec_t* exec, const uint8_t* begin,
                              const uint8_t* end, F&& con,
                              const ::std::chrono::milliseconds& timeout = {}) {
  return new detail::SdoDownloadDcfRequestWrapper(
      exec, begin, end, ::std::forward<F>(con), timeout);
}

template <class F>
inline detail::SdoDownloadDcfRequestWrapper*
make_sdo_download_dcf_request(ev_exec_t* exec, const char* path, F&& con,
                              const ::std::chrono::milliseconds& timeout = {}) {
  return new detail::SdoDownloadDcfRequestWrapper(
      exec, path, ::std::forward<F>(con), timeout);
}

template <class T, class F>
inline detail::SdoUploadRequestWrapper<T>*
make_sdo_upload_request(ev_exec_t* exec, uint16_t idx, uint8_t subidx, F&& con,
                        bool block = false,
                        const ::std::chrono::milliseconds& timeout = {}) {
  return new detail::SdoUploadRequestWrapper<T>(
      exec, idx, subidx, ::std::forward<F>(con), block, timeout);
}

class Sdo {
  template <class>
  friend class SdoDownloadRequest;
 
  friend class SdoDownloadDcfRequest;
 
  template <class>
  friend class SdoUploadRequest;
 
  template <class>
  friend class detail::SdoDownloadRequestWrapper;
 
  friend class detail::SdoDownloadDcfRequestWrapper;
 
  template <class>
  friend class detail::SdoUploadRequestWrapper;
 
 public:
  Sdo();

  Sdo(__can_net* net, uint8_t id);

  Sdo(__can_net* net, __co_dev* dev, uint8_t num);

  Sdo(__co_csdo* sdo);
 
  Sdo(const Sdo&) = delete;
  Sdo(Sdo&&) = default;
 
  Sdo& operator=(const Sdo&) = delete;
  Sdo& operator=(Sdo&&);

  ~Sdo();

  explicit operator bool() const noexcept { return !!impl_; }

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value>::type
  SubmitDownload(SdoDownloadRequest<T>& req) {
    Submit(req);
  }

  template <class T, class F, class U = typename ::std::decay<T>::type>
  typename ::std::enable_if<is_canopen<U>::value>::type
  SubmitDownload(ev_exec_t* exec, uint16_t idx, uint8_t subidx, T&& value,
                 F&& con, bool block = false,
                 const ::std::chrono::milliseconds& timeout = {}) {
    Submit(*make_sdo_download_request<U>(
        exec, idx, subidx, ::std::forward<T>(value), ::std::forward<F>(con),
        block, timeout));
  }

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value, bool>::type
  CancelDownload(SdoDownloadRequest<T>& req, SdoErrc ac) {
    return Cancel(req, ac);
  }

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value, bool>::type
  AbortDownload(SdoDownloadRequest<T>& req) {
    return Abort(req);
  }

  void
  SubmitDownloadDcf(SdoDownloadDcfRequest& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitDownloadDcf(ev_exec_t* exec, const uint8_t* begin, const uint8_t* end,
                    F&& con, const ::std::chrono::milliseconds& timeout = {}) {
    Submit(*make_sdo_download_dcf_request(exec, begin, end,
                                          ::std::forward<F>(con), timeout));
  }

  template <class F>
  void
  SubmitDownloadDcf(ev_exec_t* exec, const char* path, F&& con,
                    const ::std::chrono::milliseconds& timeout = {}) {
    Submit(*make_sdo_download_dcf_request(exec, path, ::std::forward<F>(con),
                                          timeout));
  }

  bool
  CancelDownloadDcf(SdoDownloadDcfRequest& req, SdoErrc ac) {
    return Cancel(req, ac);
  }

  bool
  AbortDownloadDcf(SdoDownloadDcfRequest& req) {
    return Abort(req);
  }

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value>::type
  SubmitUpload(SdoUploadRequest<T>& req) {
    Submit(req);
  }

  template <class T, class F>
  typename ::std::enable_if<is_canopen<T>::value>::type
  SubmitUpload(ev_exec_t* exec, uint16_t idx, uint8_t subidx, F&& con,
               bool block = false,
               const ::std::chrono::milliseconds& timeout = {}) {
    Submit(*make_sdo_upload_request<T>(exec, idx, subidx,
                                       ::std::forward<F>(con), block, timeout));
  }

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value, bool>::type
  CancelUpload(SdoUploadRequest<T>& req, SdoErrc ac) {
    return Cancel(req, ac);
  }

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value, bool>::type
  AbortUpload(SdoUploadRequest<T>& req) {
    return Abort(req);
  }

  template <class T, class U = typename ::std::decay<T>::type>
  typename ::std::enable_if<is_canopen<U>::value, SdoFuture<void>>::type
  AsyncDownload(ev_exec_t* exec, uint16_t idx, uint8_t subidx, T&& value,
                bool block = false,
                const ::std::chrono::milliseconds& timeout = {}) {
    SdoPromise<void> p;
    SubmitDownload(
        exec, idx, subidx, ::std::forward<T>(value),
        [p](uint8_t id, uint16_t idx, uint8_t subidx,
            ::std::error_code ec) mutable {
          if (ec)
            p.set(util::failure(
                make_sdo_exception_ptr(id, idx, subidx, ec, "AsyncDownload")));
          else
            p.set(util::success());
        },
        block, timeout);
    return p.get_future();
  }

  SdoFuture<void> AsyncDownloadDcf(
      ev_exec_t* exec, const uint8_t* begin, const uint8_t* end,
      const ::std::chrono::milliseconds& timeout = {});

  SdoFuture<void> AsyncDownloadDcf(
      ev_exec_t* exec, const char* path,
      const ::std::chrono::milliseconds& timeout = {});

  template <class T>
  typename ::std::enable_if<is_canopen<T>::value, SdoFuture<T>>::type
  AsyncUpload(ev_exec_t* exec, uint16_t idx, uint8_t subidx, bool block = false,
              const ::std::chrono::milliseconds& timeout = {}) {
    SdoPromise<T> p;
    SubmitUpload<T>(
        exec, idx, subidx,
        [p](uint8_t id, uint16_t idx, uint8_t subidx, ::std::error_code ec,
            T value) mutable {
          if (ec)
            p.set(util::failure(
                make_sdo_exception_ptr(id, idx, subidx, ec, "AsyncUpload")));
          else
            p.set(util::success(::std::move(value)));
        },
        block, timeout);
    return p.get_future();
  }

  void Submit(detail::SdoRequestBase& req);

  bool Cancel(detail::SdoRequestBase& req, SdoErrc ac);

  ::std::size_t CancelAll(SdoErrc ac);

  bool Abort(detail::SdoRequestBase& req);

  ::std::size_t AbortAll();
 
 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COAPP_SDO_HPP_