sdo.hpp

Go to the documentation of this file.

 
#ifndef LELY_COAPP_SDO_HPP_
#define LELY_COAPP_SDO_HPP_
 
#include <lely/aio/exec.hpp>
#include <lely/aio/future.hpp>
#include <lely/coapp/detail/type_traits.hpp>
#include <lely/coapp/sdo_error.hpp>
 
#include <chrono>
#include <memory>
#include <tuple>
 
namespace lely {
 
// The CAN network interface from <lely/can/net.hpp>.
class CANNet;
 
// The CANopen device from <lely/co/dev.hpp>.
class CODev;
 
// The CANopen Client-SDO service from <lely/co/csdo.hpp>.
class COCSDO;
 
namespace canopen {
 
class Sdo {
 public:
  using duration = ::std::chrono::milliseconds;
 
 private:
  struct Impl_;
 
  class RequestBase_ : public aio_task {
    friend class Sdo;
 
   public:
    RequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func)
        : aio_task AIO_TASK_INIT(exec, func) {}
 
    RequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func, uint16_t idx_,
                 uint8_t subidx_, const duration& timeout_)
        : aio_task AIO_TASK_INIT(exec, func),
          idx(idx_),
          subidx(subidx_),
          timeout(timeout_) {}
 
    RequestBase_(const RequestBase_&) = delete;
 
    RequestBase_& operator=(const RequestBase_&) = delete;
 
    virtual ~RequestBase_() = default;
 
    aio::ExecutorBase
    GetExecutor() const noexcept {
      return aio::ExecutorBase(exec);
    }
 
    uint16_t idx{0};
    uint8_t subidx{0};
    duration timeout{};
    uint32_t ac{0};
 
   private:
    virtual void OnRequest(Impl_* impl) noexcept = 0;
  };
 
  template <class T>
  class DownloadRequestBase_ : public RequestBase_ {
   public:
    DownloadRequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func)
        : RequestBase_(exec, func) {}
 
    template <class U>
    DownloadRequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func,
                         uint16_t idx, uint8_t subidx, U&& value_,
                         const duration& timeout)
        : RequestBase_(exec, func, idx, subidx, timeout),
          value(::std::forward<U>(value_)) {}
 
    T value{};
  };
 
  template <class T>
  class UploadRequestBase_ : public RequestBase_ {
    friend Impl_;
 
   public:
    using RequestBase_::RequestBase_;
 
    T value{};
  };
 
 public:
  using DownloadSignature = void(uint16_t idx, uint8_t subidx,
                                 ::std::error_code ec);
 
  template <class T>
  class DownloadRequest : public DownloadRequestBase_<T> {
   public:
    template <class F>
    DownloadRequest(aio::ExecutorBase& exec, F&& con)
        : DownloadRequestBase_<T>(exec, &Func_), con_(::std::forward<F>(con)) {}
 
    template <class U, class F>
    DownloadRequest(uint16_t idx, uint8_t subidx, U&& value,
                    aio::ExecutorBase& exec, F&& con, const duration& timeout)
        : DownloadRequestBase_<T>(exec, &Func_, idx, subidx,
                                  ::std::forward<U>(value), timeout),
          con_(::std::forward<F>(con)) {}
 
   private:
    void OnRequest(Impl_* impl) noexcept override;
 
    static void Func_(aio_task* task) noexcept;
 
    ::std::function<DownloadSignature> con_{nullptr};
  };
 
  template <class T>
  using UploadSignature = void(uint16_t idx, uint8_t subidx,
                               ::std::error_code ec, T value);
 
  template <class T>
  class UploadRequest : public UploadRequestBase_<T> {
   public:
    template <class F>
    UploadRequest(aio::ExecutorBase& exec, F&& con)
        : UploadRequestBase_<T>(exec, &Func_), con_(::std::forward<F>(con)) {}
 
    template <class F>
    UploadRequest(uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
                  F&& con, const duration& timeout)
        : UploadRequestBase_<T>(exec, &Func_, idx, subidx, timeout),
          con_(::std::forward<F>(con)) {}
 
   private:
    void OnRequest(Impl_* impl) noexcept override;
 
    static void Func_(aio_task* task) noexcept;
 
    ::std::function<UploadSignature<T>> con_{nullptr};
  };
 
  Sdo();
 
  Sdo(CANNet* net, uint8_t id);
 
  Sdo(CANNet* net, CODev* dev, uint8_t num);
 
  explicit Sdo(COCSDO* 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<detail::IsCanopenType<T>::value>::type
  SubmitDownload(DownloadRequest<T>& req) {
    Submit(static_cast<RequestBase_&>(req));
  }
 
  template <class T, class F, class U = typename ::std::decay<T>::type>
  typename ::std::enable_if<
      detail::IsCanopenType<typename ::std::decay<U>::type>::value>::type
  SubmitDownload(uint16_t idx, uint8_t subidx, T&& value,
                 aio::ExecutorBase& exec, F&& con, const duration& timeout) {
    auto req =
        new DownloadRequestWrapper<U>(idx, subidx, ::std::forward<T>(value),
                                      exec, ::std::forward<F>(con), timeout);
    Submit(*req);
  }
 
  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value,
                            ::std::size_t>::type
  CancelDownload(DownloadRequest<T>& req, SdoErrc ac) {
    return Cancel(req, ac);
  }
 
  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type
  SubmitUpload(UploadRequest<T>& req) {
    Submit(static_cast<RequestBase_&>(req));
  }
 
  template <class T, class F>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type
  SubmitUpload(uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec, F&& con,
               const duration& timeout) {
    auto req = new UploadRequestWrapper<T>(idx, subidx, exec,
                                           ::std::forward<F>(con), timeout);
    Submit(*req);
  }
 
  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value,
                            ::std::size_t>::type
  CancelUpload(UploadRequest<T>& req, SdoErrc ac) {
    return Cancel(req, ac);
  }
 
  ::std::size_t Cancel(SdoErrc ac);
 
  template <class T, class U = typename ::std::decay<T>::type>
  typename ::std::enable_if<detail::IsCanopenType<U>::value,
                            aio::Future<::std::error_code>>::type
  AsyncDownload(aio::LoopBase& loop, aio::ExecutorBase& exec, int16_t idx,
                uint8_t subidx, T&& value, const duration& timeout) {
    auto req = new AsyncDownloadRequest<U>(loop, exec, idx, subidx,
                                           ::std::forward<T>(value), timeout);
    Submit(*req);
    return req->GetFuture();
  }
 
  template <class T>
  typename ::std::enable_if<
      detail::IsCanopenType<T>::value,
      aio::Future<::std::tuple<::std::error_code, T>>>::type
  AsyncUpload(aio::LoopBase& loop, aio::ExecutorBase& exec, int16_t idx,
              uint8_t subidx, const duration& timeout) {
    auto req = new AsyncUploadRequest<T>(loop, exec, idx, subidx, timeout);
    Submit(*req);
    return req->GetFuture();
  }
 
 private:
  template <class T>
  class DownloadRequestWrapper : public DownloadRequestBase_<T> {
   public:
    template <class U, class F>
    DownloadRequestWrapper(uint16_t idx, int8_t subidx, U&& value,
                           aio::ExecutorBase& exec, F&& con,
                           const duration& timeout)
        : DownloadRequestBase_<T>(exec, &Func_, idx, subidx,
                                  ::std::forward<U>(value), timeout),
          con_(::std::forward<F>(con)) {}
 
   private:
    ~DownloadRequestWrapper() = default;
 
    void OnRequest(Impl_* impl) noexcept override;
 
    static void Func_(aio_task* task) noexcept;
 
    ::std::function<DownloadSignature> con_{nullptr};
  };
 
  template <class T>
  class UploadRequestWrapper : public UploadRequestBase_<T> {
   public:
    template <class F>
    UploadRequestWrapper(uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
                         F&& con, const duration& timeout)
        : UploadRequestBase_<T>(exec, &Func_, idx, subidx, timeout),
          con_(::std::forward<F>(con)) {}
 
   private:
    ~UploadRequestWrapper() = default;
 
    void OnRequest(Impl_* impl) noexcept override;
 
    static void Func_(aio_task* task) noexcept;
 
    ::std::function<UploadSignature<T>> con_{nullptr};
  };
 
  template <class T>
  class AsyncDownloadRequest : public DownloadRequestBase_<T> {
   public:
    template <class U>
    AsyncDownloadRequest(aio::LoopBase& loop, aio::ExecutorBase& exec,
                         uint16_t idx, int8_t subidx, U&& value,
                         const duration& timeout)
        : DownloadRequestBase_<T>(exec, &Func_, idx, subidx,
                                  ::std::forward<U>(value), timeout),
          promise_(loop, exec) {}
 
    aio::Future<::std::error_code>
    GetFuture() noexcept {
      return promise_.GetFuture();
    }
 
   private:
    ~AsyncDownloadRequest() = default;
 
    void OnRequest(Impl_* impl) noexcept override;
 
    static void Func_(aio_task* task) noexcept;
 
    aio::Promise<::std::error_code> promise_;
  };
 
  template <class T>
  class AsyncUploadRequest : public UploadRequestBase_<T> {
   public:
    AsyncUploadRequest(aio::LoopBase& loop, aio::ExecutorBase& exec,
                       uint16_t idx, int8_t subidx, const duration& timeout)
        : UploadRequestBase_<T>(exec, &Func_, idx, subidx, timeout),
          promise_(loop, exec) {}
 
    aio::Future<::std::tuple<::std::error_code, T>>
    GetFuture() noexcept {
      return promise_.GetFuture();
    }
 
   private:
    ~AsyncUploadRequest() = default;
 
    void OnRequest(Impl_* impl) noexcept override;
 
    static void Func_(aio_task* task) noexcept;
 
    aio::Promise<::std::tuple<::std::error_code, T>> promise_;
  };
 
  void Submit(RequestBase_& req);
 
  ::std::size_t Cancel(RequestBase_& req, SdoErrc ac);
 
  ::std::unique_ptr<Impl_> impl_;
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COAPP_SDO_HPP_