Lely core libraries  2.3.4
master.hpp
Go to the documentation of this file.
1 
22 #ifndef LELY_COCPP_MASTER_HPP_
23 #define LELY_COCPP_MASTER_HPP_
24 
25 #include <lely/coapp/node.hpp>
26 #include <lely/coapp/sdo.hpp>
27 
28 #include <map>
29 #include <memory>
30 #include <string>
31 #include <utility>
32 
33 #include <cstddef>
34 
35 namespace lely {
36 
37 namespace canopen {
38 
39 class DriverBase;
40 
50 class BasicMaster : public Node, protected ::std::map<uint8_t, DriverBase*> {
51  public:
52  class Object;
53  class ConstObject;
54 
59  class SubObject {
60  friend class Object;
61 
62  public:
63  SubObject(const SubObject&) = default;
64  SubObject(SubObject&&) = default;
65 
66  SubObject& operator=(const SubObject&) = default;
67  SubObject& operator=(SubObject&&) = default;
68 
79  template <class T>
80  SubObject&
81  operator=(T&& value) {
82  return Write(::std::forward<T>(value));
83  }
84 
93  template <class T>
94  operator T() const {
95  return Read<T>();
96  }
97 
109  template <class T>
110  T
111  Read() const {
112  return id_ ? master_->TpdoRead<T>(id_, idx_, subidx_)
113  : master_->Read<T>(idx_, subidx_);
114  }
115 
127  template <class T>
128  T
129  Read(::std::error_code& ec) const {
130  return id_ ? master_->TpdoRead<T>(id_, idx_, subidx_, ec)
131  : master_->Read<T>(idx_, subidx_, ec);
132  }
133 
147  template <class T>
148  SubObject&
149  Write(T&& value) {
150  if (id_)
151  master_->TpdoWrite(id_, idx_, subidx_, ::std::forward<T>(value));
152  else
153  master_->Write(idx_, subidx_, ::std::forward<T>(value));
154  return *this;
155  }
156 
172  template <class T>
173  SubObject&
174  Write(T&& value, ::std::error_code& ec) {
175  if (id_)
176  master_->TpdoWrite(id_, idx_, subidx_, ::std::forward<T>(value), ec);
177  else
178  master_->Write(idx_, subidx_, ::std::forward<T>(value), ec);
179  return *this;
180  }
181 
195  SubObject&
196  Write(const void* p, ::std::size_t n) {
197  if (!id_) master_->Write(idx_, subidx_, p, n);
198  return *this;
199  }
200 
213  SubObject&
214  Write(const void* p, ::std::size_t n, ::std::error_code& ec) {
215  if (!id_) master_->Write(idx_, subidx_, p, n, ec);
216  return *this;
217  }
218 
229  void
231  if (id_)
232  master_->TpdoWriteEvent(id_, idx_, subidx_);
233  else
234  master_->WriteEvent(idx_, subidx_);
235  }
236 
247  void
248  WriteEvent(::std::error_code& ec) noexcept {
249  if (id_)
250  master_->TpdoWriteEvent(id_, idx_, subidx_, ec);
251  else
252  master_->WriteEvent(idx_, subidx_, ec);
253  }
254 
255  private:
256  SubObject(BasicMaster* master, uint16_t idx, uint8_t subidx) noexcept
257  : SubObject(master, 0, idx, subidx) {}
258 
259  SubObject(BasicMaster* master, uint8_t id, uint16_t idx,
260  uint8_t subidx) noexcept
261  : master_(master), idx_(idx), subidx_(subidx), id_(id) {}
262 
263  BasicMaster* master_;
264  uint16_t idx_;
265  uint8_t subidx_;
266  uint8_t id_;
267  };
268 
274  friend class Object;
275  friend class ConstObject;
276 
277  public:
286  template <class T>
287  operator T() const {
288  return Read<T>();
289  }
290 
303  template <class T>
304  T
305  Read() const {
306  return id_ ? (is_rpdo_ ? master_->RpdoRead<T>(id_, idx_, subidx_)
307  : master_->TpdoRead<T>(id_, idx_, subidx_))
308  : master_->Read<T>(idx_, subidx_);
309  }
310 
323  template <class T>
324  T
325  Read(::std::error_code& ec) const {
326  return id_ ? (is_rpdo_ ? master_->RpdoRead<T>(id_, idx_, subidx_, ec)
327  : master_->TpdoRead<T>(id_, idx_, subidx_, ec))
328  : master_->Read<T>(idx_, subidx_, ec);
329  }
330 
331  private:
332  ConstSubObject(const BasicMaster* master, uint16_t idx,
333  uint8_t subidx) noexcept
334  : ConstSubObject(master, 0, idx, subidx, false) {}
335 
336  ConstSubObject(const BasicMaster* master, uint8_t id, uint16_t idx,
337  uint8_t subidx, bool is_rpdo) noexcept
338  : master_(master),
339  idx_(idx),
340  subidx_(subidx),
341  id_(id),
342  is_rpdo_(is_rpdo) {}
343 
344  const BasicMaster* master_;
345  uint16_t idx_;
346  uint8_t subidx_;
347  uint8_t id_ : 7;
348  uint8_t is_rpdo_ : 1;
349  };
350 
351  class RpdoMapped;
352  class TpdoMapped;
353 
358  class Object {
359  friend class TpdoMapped;
360  friend class BasicMaster;
361 
362  public:
374  SubObject
375  operator[](uint8_t subidx) noexcept {
376  return SubObject(master_, id_, idx_, subidx);
377  }
378 
391  operator[](uint8_t subidx) const noexcept {
392  return ConstSubObject(master_, id_, idx_, subidx, false);
393  }
394 
395  private:
396  Object(BasicMaster* master, uint16_t idx) noexcept
397  : Object(master, 0, idx) {}
398 
399  Object(BasicMaster* master, uint8_t id, uint16_t idx) noexcept
400  : master_(master), idx_(idx), id_(id) {}
401 
402  BasicMaster* master_;
403  uint16_t idx_;
404  uint8_t id_;
405  };
406 
411  class ConstObject {
412  friend class RpdoMapped;
413  friend class TpdoMapped;
414  friend class BasicMaster;
415 
416  public:
429  operator[](uint8_t subidx) const noexcept {
430  return ConstSubObject(master_, id_, idx_, subidx, is_rpdo_);
431  }
432 
433  private:
434  ConstObject(const BasicMaster* master, uint16_t idx) noexcept
435  : ConstObject(master, 0, idx, false) {}
436 
437  ConstObject(const BasicMaster* master, uint8_t id, uint16_t idx,
438  bool is_rpdo) noexcept
439  : master_(master), idx_(idx), id_(id), is_rpdo_(is_rpdo) {}
440 
441  const BasicMaster* master_;
442  uint16_t idx_;
443  uint8_t id_ : 7;
444  uint8_t is_rpdo_ : 1;
445  };
446 
451  class RpdoMapped {
452  friend class BasicMaster;
453 
454  public:
466  operator[](uint16_t idx) const noexcept {
467  return ConstObject(master_, id_, idx, true);
468  }
469 
470  private:
471  RpdoMapped(const BasicMaster* master, uint8_t id) noexcept
472  : master_(master), id_(id) {}
473 
474  const BasicMaster* master_;
475  uint8_t id_;
476  };
477 
482  class TpdoMapped {
483  friend class BasicMaster;
484 
485  public:
496  Object
497  operator[](uint16_t idx) noexcept {
498  return Object(master_, id_, idx);
499  }
500 
512  operator[](uint16_t idx) const noexcept {
513  return ConstObject(master_, id_, idx, false);
514  }
515 
516  private:
517  TpdoMapped(BasicMaster* master, uint8_t id) noexcept
518  : master_(master), id_(id) {}
519 
520  BasicMaster* master_;
521  uint8_t id_;
522  };
523 
526  friend class BasicMaster;
527 
528  public:
529  void lock() override;
530  void unlock() override;
531 
532  protected:
533  using Node::TpdoEventMutex::TpdoEventMutex;
534  };
535 
549  template <class T>
550  using ReadSignature = void(uint8_t id, uint16_t idx, uint8_t subidx,
551  ::std::error_code ec, T value);
552 
565  using WriteSignature = void(uint8_t id, uint16_t idx, uint8_t subidx,
566  ::std::error_code ec);
567 
588  explicit BasicMaster(ev_exec_t* exec, io::TimerBase& timer,
589  io::CanChannelBase& chan, const ::std::string& dcf_txt,
590  const ::std::string& dcf_bin = "", uint8_t id = 0xff);
591 
594  const ::std::string& dcf_txt,
595  const ::std::string& dcf_bin = "", uint8_t id = 0xff)
596  : BasicMaster(nullptr, timer, chan, dcf_txt, dcf_bin, id) {}
597 
598  virtual ~BasicMaster();
599 
610  Object
611  operator[](::std::ptrdiff_t idx) noexcept {
612  return Object(this, idx);
613  }
614 
625  ConstObject
626  operator[](::std::ptrdiff_t idx) const noexcept {
627  return ConstObject(this, idx);
628  }
629 
640  RpdoMapped
641  RpdoMapped(uint8_t id) const noexcept {
642  return {this, id};
643  }
644 
655  TpdoMapped
656  TpdoMapped(uint8_t id) noexcept {
657  return {this, id};
658  }
659 
664  bool Boot(uint8_t id);
665 
677  bool IsReady(uint8_t id) const;
678 
688  ev::Future<void> AsyncDeconfig(uint8_t id);
689 
700 
710  void Error(uint8_t id);
711 
712  /*
713  * Generates an EMCY error and triggers the error handling behavior according
714  * to object 1029:01 (Error behavior object) in case of a communication error
715  * (emergency error code 0x81xx).
716  *
717  * @param eec the emergency error code.
718  * @param er the error register.
719  * @param msef the manufacturer-specific error code.
720  */
721  void Error(uint16_t eec, uint8_t er,
722  const uint8_t msef[5] = nullptr) noexcept;
723 
730  void Command(NmtCommand cs, uint8_t id = 0);
731 
733  void RpdoRtr(int num = 0) noexcept;
734 
736  void TpdoEvent(int num = 0) noexcept;
737 
739  template <class T>
740  void
741  DamMpdoEvent(int num, uint8_t id, uint16_t idx, uint8_t subidx, T value) {
742  ::std::lock_guard<BasicLockable> lock(*this);
743 
744  Node::DamMpdoEvent(num, id, idx, subidx, value);
745  }
746 
753  ::std::chrono::milliseconds GetTimeout() const;
754 
761  void SetTimeout(const ::std::chrono::milliseconds& timeout);
762 
768  template <class T>
769  void
770  SubmitRead(uint8_t id, SdoUploadRequest<T>& req) {
771  ::std::error_code ec;
772  SubmitRead(id, req, ec);
773  if (ec) throw SdoError(id, req.idx, req.subidx, ec, "SubmitRead");
774  }
775 
784  template <class T>
785  void
786  SubmitRead(uint8_t id, SdoUploadRequest<T>& req, ::std::error_code& ec) {
787  ::std::lock_guard<BasicLockable> lock(*this);
788 
789  ec.clear();
790  auto sdo = GetSdo(id);
791  if (sdo) {
792  SetTime();
793  sdo->SubmitUpload(req);
794  } else {
795  ec = SdoErrc::NO_SDO;
796  }
797  }
798 
804  template <class T, class F>
805  void
806  SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
807  F&& con) {
808  SubmitRead<T>(exec, id, idx, subidx, ::std::forward<F>(con), GetTimeout());
809  }
810 
816  template <class T, class F>
817  void
818  SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx, F&& con,
819  ::std::error_code& ec) {
820  SubmitRead<T>(exec, id, idx, subidx, ::std::forward<F>(con), GetTimeout(),
821  ec);
822  }
823 
829  template <class T, class F>
830  void
831  SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx, F&& con,
832  const ::std::chrono::milliseconds& timeout) {
833  ::std::error_code ec;
834  SubmitRead<T>(exec, id, idx, subidx, ::std::forward<F>(con), timeout, ec);
835  if (ec) throw SdoError(id, idx, subidx, ec, "SubmitRead");
836  }
837 
855  template <class T, class F>
856  void
857  SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx, F&& con,
858  const ::std::chrono::milliseconds& timeout,
859  ::std::error_code& ec) {
860  SubmitUpload<T>(exec, id, idx, subidx, ::std::forward<F>(con), false,
861  timeout, ec);
862  }
863 
869  template <class T, class F>
870  void
871  SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
872  F&& con) {
873  SubmitBlockRead<T>(exec, id, idx, subidx, ::std::forward<F>(con),
874  GetTimeout());
875  }
876 
882  template <class T, class F>
883  void
884  SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
885  F&& con, ::std::error_code& ec) {
886  SubmitBlockRead<T>(exec, id, idx, subidx, ::std::forward<F>(con),
887  GetTimeout(), ec);
888  }
889 
895  template <class T, class F>
896  void
897  SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
898  F&& con, const ::std::chrono::milliseconds& timeout) {
899  ::std::error_code ec;
900  SubmitBlockRead<T>(exec, id, idx, subidx, ::std::forward<F>(con), timeout,
901  ec);
902  if (ec) throw SdoError(id, idx, subidx, ec, "SubmitBlockRead");
903  }
904 
926  template <class T, class F>
927  void
928  SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
929  F&& con, const ::std::chrono::milliseconds& timeout,
930  ::std::error_code& ec) {
931  SubmitUpload<T>(exec, id, idx, subidx, ::std::forward<F>(con), true,
932  timeout, ec);
933  }
934 
953  template <class T, class F>
954  void
955  SubmitUpload(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
956  F&& con, bool block, const ::std::chrono::milliseconds& timeout,
957  ::std::error_code& ec) {
958  ::std::lock_guard<BasicLockable> lock(*this);
959 
960  ec.clear();
961  auto sdo = GetSdo(id);
962  if (sdo) {
963  SetTime();
964  sdo->SubmitUpload<T>(exec, idx, subidx, ::std::forward<F>(con), block,
965  timeout);
966  } else {
967  ec = SdoErrc::NO_SDO;
968  }
969  }
970 
976  template <class T>
977  void
978  SubmitWrite(uint8_t id, SdoDownloadRequest<T>& req) {
979  ::std::error_code ec;
980  SubmitWrite(id, req, ec);
981  if (ec) throw SdoError(id, req.idx, req.subidx, ec, "SubmitWrite");
982  }
983 
992  template <class T>
993  void
994  SubmitWrite(uint8_t id, SdoDownloadRequest<T>& req, ::std::error_code& ec) {
995  ::std::lock_guard<BasicLockable> lock(*this);
996 
997  ec.clear();
998  auto sdo = GetSdo(id);
999  if (sdo) {
1000  SetTime();
1001  sdo->SubmitDownload(req);
1002  } else {
1003  ec = SdoErrc::NO_SDO;
1004  }
1005  }
1006 
1012  template <class T, class F>
1013  void
1014  SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1015  T&& value, F&& con) {
1016  SubmitWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1017  ::std::forward<F>(con), GetTimeout());
1018  }
1019 
1025  template <class T, class F>
1026  void
1027  SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1028  T&& value, F&& con, ::std::error_code& ec) {
1029  SubmitWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1030  ::std::forward<F>(con), GetTimeout(), ec);
1031  }
1032 
1038  template <class T, class F>
1039  void
1040  SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1041  T&& value, F&& con, const ::std::chrono::milliseconds& timeout) {
1042  ::std::error_code ec;
1043  SubmitWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1044  ::std::forward<F>(con), timeout, ec);
1045  if (ec) throw SdoError(id, idx, subidx, ec, "SubmitWrite");
1046  }
1047 
1066  template <class T, class F>
1067  void
1068  SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1069  T&& value, F&& con, const ::std::chrono::milliseconds& timeout,
1070  ::std::error_code& ec) {
1071  SubmitDownload(exec, id, idx, subidx, ::std::forward<T>(value),
1072  ::std::forward<F>(con), false, timeout, ec);
1073  }
1074 
1080  template <class T, class F>
1081  void
1082  SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1083  T&& value, F&& con) {
1084  SubmitBlockWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1085  ::std::forward<F>(con), GetTimeout());
1086  }
1087 
1093  template <class T, class F>
1094  void
1095  SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1096  T&& value, F&& con, ::std::error_code& ec) {
1097  SubmitBlockWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1098  ::std::forward<F>(con), GetTimeout(), ec);
1099  }
1100 
1106  template <class T, class F>
1107  void
1108  SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1109  T&& value, F&& con,
1110  const ::std::chrono::milliseconds& timeout) {
1111  ::std::error_code ec;
1112  SubmitBlockWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1113  ::std::forward<F>(con), timeout, ec);
1114  if (ec) throw SdoError(id, idx, subidx, ec, "SubmitBlockWrite");
1115  }
1116 
1139  template <class T, class F>
1140  void
1141  SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1142  T&& value, F&& con,
1143  const ::std::chrono::milliseconds& timeout,
1144  ::std::error_code& ec) {
1145  SubmitDownload(exec, id, idx, subidx, ::std::forward<T>(value),
1146  ::std::forward<F>(con), true, timeout, ec);
1147  }
1148 
1168  template <class T, class F>
1169  void
1170  SubmitDownload(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1171  T&& value, F&& con, bool block,
1172  const ::std::chrono::milliseconds& timeout,
1173  ::std::error_code& ec) {
1174  ::std::lock_guard<BasicLockable> lock(*this);
1175 
1176  ec.clear();
1177  auto sdo = GetSdo(id);
1178  if (sdo) {
1179  SetTime();
1180  sdo->SubmitDownload(exec, idx, subidx, ::std::forward<T>(value),
1181  ::std::forward<F>(con), block, timeout);
1182  } else {
1183  ec = SdoErrc::NO_SDO;
1184  }
1185  }
1186 
1192  void SubmitWriteDcf(uint8_t id, SdoDownloadDcfRequest& req);
1193 
1202  void SubmitWriteDcf(uint8_t id, SdoDownloadDcfRequest& req,
1203  ::std::error_code& ec);
1204 
1210  template <class F>
1211  void
1212  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t* begin,
1213  const uint8_t* end, F&& con) {
1214  SubmitWriteDcf(exec, id, begin, end, ::std::forward<F>(con), GetTimeout());
1215  }
1216 
1222  template <class F>
1223  void
1224  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t* begin,
1225  const uint8_t* end, F&& con, ::std::error_code& ec) {
1226  SubmitWriteDcf(exec, id, begin, end, ::std::forward<F>(con), GetTimeout(),
1227  ec);
1228  }
1229 
1235  template <class F>
1236  void
1237  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t* begin,
1238  const uint8_t* end, F&& con,
1239  const ::std::chrono::milliseconds& timeout) {
1240  ::std::error_code ec;
1241  SubmitWriteDcf(exec, id, begin, end, ::std::forward<F>(con), timeout, ec);
1242  if (ec) throw SdoError(id, 0, 0, ec, "SubmitWriteDcf");
1243  }
1244 
1266  template <class F>
1267  void
1268  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t* begin,
1269  const uint8_t* end, F&& con,
1270  const ::std::chrono::milliseconds& timeout,
1271  ::std::error_code& ec) {
1272  ::std::lock_guard<BasicLockable> lock(*this);
1273 
1274  ec.clear();
1275  auto sdo = GetSdo(id);
1276  if (sdo) {
1277  SetTime();
1278  sdo->SubmitDownloadDcf(exec, begin, end, ::std::forward<F>(con), timeout);
1279  } else {
1280  ec = SdoErrc::NO_SDO;
1281  }
1282  }
1283 
1289  template <class F>
1290  void
1291  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con) {
1292  SubmitWriteDcf(exec, id, path, ::std::forward<F>(con), GetTimeout());
1293  }
1294 
1300  template <class F>
1301  void
1302  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con,
1303  ::std::error_code& ec) {
1304  SubmitWriteDcf(exec, id, path, ::std::forward<F>(con), GetTimeout(), ec);
1305  }
1306 
1312  template <class F>
1313  void
1314  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con,
1315  const ::std::chrono::milliseconds& timeout) {
1316  ::std::error_code ec;
1317  SubmitWriteDcf(exec, id, path, ::std::forward<F>(con), timeout, ec);
1318  if (ec) throw SdoError(id, 0, 0, ec, "SubmitWriteDcf");
1319  }
1320 
1339  template <class F>
1340  void
1341  SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con,
1342  const ::std::chrono::milliseconds& timeout,
1343  ::std::error_code& ec) {
1344  ::std::lock_guard<BasicLockable> lock(*this);
1345 
1346  ec.clear();
1347  auto sdo = GetSdo(id);
1348  if (sdo) {
1349  SetTime();
1350  sdo->SubmitDownloadDcf(exec, path, ::std::forward<F>(con), timeout);
1351  } else {
1352  ec = SdoErrc::NO_SDO;
1353  }
1354  }
1355 
1361  template <class T>
1362  SdoFuture<T>
1363  AsyncRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx) {
1364  return AsyncRead<T>(exec, id, idx, subidx, GetTimeout());
1365  }
1366 
1383  template <class T>
1384  SdoFuture<T>
1385  AsyncRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1386  const ::std::chrono::milliseconds& timeout) {
1387  return AsyncUpload<T>(exec, id, idx, subidx, false, timeout);
1388  }
1389 
1395  template <class T>
1396  SdoFuture<T>
1397  AsyncBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx) {
1398  return AsyncBlockRead<T>(exec, id, idx, subidx, GetTimeout());
1399  }
1400 
1421  template <class T>
1422  SdoFuture<T>
1423  AsyncBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1424  const ::std::chrono::milliseconds& timeout) {
1425  return AsyncUpload<T>(exec, id, idx, subidx, true, timeout);
1426  }
1427 
1446  template <class T>
1447  SdoFuture<T>
1448  AsyncUpload(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1449  bool block, const ::std::chrono::milliseconds& timeout) {
1450  if (!exec) exec = GetExecutor();
1451 
1452  ::std::lock_guard<BasicLockable> lock(*this);
1453 
1454  auto sdo = GetSdo(id);
1455  if (sdo) {
1456  SetTime();
1457  return sdo->AsyncUpload<T>(exec, idx, subidx, block, timeout);
1458  } else {
1459  return make_error_sdo_future<T>(id, idx, subidx, SdoErrc::NO_SDO,
1460  "AsyncRead");
1461  }
1462  }
1463 
1469  template <class T>
1471  AsyncWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1472  T&& value) {
1473  return AsyncWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1474  GetTimeout());
1475  }
1476 
1493  template <class T>
1495  AsyncWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1496  T&& value, const ::std::chrono::milliseconds& timeout) {
1497  return AsyncDownload(exec, id, idx, subidx, ::std::forward<T>(value), false,
1498  timeout);
1499  }
1500 
1506  template <class T>
1508  AsyncBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1509  T&& value) {
1510  return AsyncBlockWrite(exec, id, idx, subidx, ::std::forward<T>(value),
1511  GetTimeout());
1512  }
1513 
1534  template <class T>
1536  AsyncBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1537  T&& value, const ::std::chrono::milliseconds& timeout) {
1538  return AsyncDownload(exec, id, idx, subidx, ::std::forward<T>(value), true,
1539  timeout);
1540  }
1541 
1560  template <class T>
1562  AsyncDownload(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,
1563  T&& value, bool block,
1564  const ::std::chrono::milliseconds& timeout) {
1565  if (!exec) exec = GetExecutor();
1566 
1567  ::std::lock_guard<BasicLockable> lock(*this);
1568 
1569  auto sdo = GetSdo(id);
1570  if (sdo) {
1571  SetTime();
1572  return sdo->AsyncDownload<T>(exec, idx, subidx, ::std::forward<T>(value),
1573  block, timeout);
1574  } else {
1575  return make_error_sdo_future<void>(id, idx, subidx, SdoErrc::NO_SDO,
1576  "AsyncWrite");
1577  }
1578  }
1579 
1586  AsyncWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t* begin,
1587  const uint8_t* end) {
1588  return AsyncWriteDcf(exec, id, begin, end, GetTimeout());
1589  }
1590 
1609  SdoFuture<void> AsyncWriteDcf(ev_exec_t* exec, uint8_t id,
1610  const uint8_t* begin, const uint8_t* end,
1611  const ::std::chrono::milliseconds& timeout);
1612 
1619  AsyncWriteDcf(ev_exec_t* exec, uint8_t id, const char* path) {
1620  return AsyncWriteDcf(exec, id, path, GetTimeout());
1621  }
1622 
1638  SdoFuture<void> AsyncWriteDcf(ev_exec_t* exec, uint8_t id, const char* path,
1639  const ::std::chrono::milliseconds& timeout);
1640 
1650  void Insert(DriverBase& driver);
1651 
1657  void Erase(DriverBase& driver);
1658 
1660  void
1663  }
1664 
1666  void
1667  OnCanError(::std::function<void(io::CanError)> on_can_error) {
1669  }
1670 
1672  void
1673  OnRpdoWrite(::std::function<void(uint8_t, uint16_t, uint8_t)> on_rpdo_write) {
1674  Node::OnRpdoWrite(on_rpdo_write);
1675  }
1676 
1678  void
1679  OnCommand(::std::function<void(NmtCommand)> on_command) {
1680  Node::OnCommand(on_command);
1681  }
1682 
1684  void
1685  OnHeartbeat(::std::function<void(uint8_t, bool)> on_heartbeat) {
1686  Node::OnHeartbeat(on_heartbeat);
1687  }
1688 
1690  void
1691  OnState(::std::function<void(uint8_t, NmtState)> on_state) {
1692  Node::OnState(on_state);
1693  }
1694 
1696  void
1697  OnSync(::std::function<void(uint8_t, const time_point&)> on_sync) {
1698  Node::OnSync(on_sync);
1699  }
1700 
1702  void
1703  OnSyncError(::std::function<void(uint16_t, uint8_t)> on_sync_error) {
1704  Node::OnSyncError(on_sync_error);
1705  }
1706 
1708  void
1709  OnTime(::std::function<void(const ::std::chrono::system_clock::time_point&)>
1710  on_time) {
1711  Node::OnTime(on_time);
1712  }
1713 
1715  void
1717  ::std::function<void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy) {
1718  Node::OnEmcy(on_emcy);
1719  }
1720 
1727  void OnNodeGuarding(::std::function<void(uint8_t, bool)> on_node_guarding);
1728 
1735  void OnBoot(
1736  ::std::function<void(uint8_t, NmtState, char, const ::std::string&)>
1737  on_boot);
1738 
1741 
1742  protected:
1743  using MapType = ::std::map<uint8_t, DriverBase*>;
1744 
1751  void OnCanState(io::CanState new_state,
1752  io::CanState old_state) noexcept override;
1753 
1759  void OnCanError(io::CanError error) noexcept override;
1760 
1767  void OnRpdoWrite(uint8_t id, uint16_t idx, uint8_t subidx) noexcept override;
1768 
1776  void OnCommand(NmtCommand cs) noexcept override;
1777 
1784  void OnHeartbeat(uint8_t id, bool occurred) noexcept override;
1785 
1795  void OnState(uint8_t id, NmtState st) noexcept override;
1796 
1802  void OnSync(uint8_t cnt, const time_point& t) noexcept override;
1803 
1809  void OnSyncError(uint16_t eec, uint8_t er) noexcept override;
1810 
1816  void OnTime(const ::std::chrono::system_clock::time_point& abs_time) noexcept
1817  override;
1818 
1825  void OnEmcy(uint8_t id, uint16_t eec, uint8_t er,
1826  uint8_t msef[5]) noexcept override;
1827 
1844  virtual void OnNodeGuarding(uint8_t id, bool occurred) noexcept;
1845 
1889  virtual void OnBoot(uint8_t id, NmtState st, char es,
1890  const ::std::string& what) noexcept;
1891 
1897  void IsReady(uint8_t id, bool ready) noexcept;
1898 
1911  virtual void OnConfig(uint8_t id) noexcept;
1912 
1919  void ConfigResult(uint8_t id, ::std::error_code ec) noexcept;
1920 
1931  bool IsConfig(uint8_t id) const;
1932 
1938  Sdo* GetSdo(uint8_t id);
1939 
1945  void CancelSdo(uint8_t id = 0);
1946 
1947  private:
1948  struct Impl_;
1949  ::std::unique_ptr<Impl_> impl_;
1950 };
1951 
1957 class AsyncMaster : public BasicMaster {
1958  public:
1960 
1962  void
1965  }
1966 
1968  void
1969  OnCanError(::std::function<void(io::CanError)> on_can_error) {
1971  }
1972 
1974  void
1975  OnRpdoWrite(::std::function<void(uint8_t, uint16_t, uint8_t)> on_rpdo_write) {
1976  BasicMaster::OnRpdoWrite(on_rpdo_write);
1977  }
1978 
1980  void
1981  OnCommand(::std::function<void(NmtCommand)> on_command) {
1982  BasicMaster::OnCommand(on_command);
1983  }
1984 
1986  void
1987  OnHeartbeat(::std::function<void(uint8_t, bool)> on_heartbeat) {
1988  BasicMaster::OnHeartbeat(on_heartbeat);
1989  }
1990 
1992  void
1993  OnState(::std::function<void(uint8_t, NmtState)> on_state) {
1994  BasicMaster::OnState(on_state);
1995  }
1996 
1998  void
1999  OnSync(::std::function<void(uint8_t, const time_point&)> on_sync) {
2000  BasicMaster::OnSync(on_sync);
2001  }
2002 
2004  void
2005  OnSyncError(::std::function<void(uint16_t, uint8_t)> on_sync_error) {
2006  BasicMaster::OnSyncError(on_sync_error);
2007  }
2008 
2010  void
2011  OnTime(::std::function<void(const ::std::chrono::system_clock::time_point&)>
2012  on_time) {
2013  BasicMaster::OnTime(on_time);
2014  }
2015 
2017  void
2019  ::std::function<void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy) {
2020  BasicMaster::OnEmcy(on_emcy);
2021  }
2022 
2024  void
2025  OnNodeGuarding(::std::function<void(uint8_t, bool)> on_node_guarding) {
2026  BasicMaster::OnNodeGuarding(on_node_guarding);
2027  }
2028 
2030  void
2031  OnBoot(::std::function<void(uint8_t, NmtState, char, const ::std::string&)>
2032  on_boot) {
2033  BasicMaster::OnBoot(on_boot);
2034  }
2035 
2036  protected:
2043  void OnCanState(io::CanState new_state,
2044  io::CanState old_state) noexcept override;
2045 
2052  void OnCanError(io::CanError error) noexcept override;
2053 
2060  void OnRpdoWrite(uint8_t id, uint16_t idx, uint8_t subidx) noexcept override;
2061 
2069  void OnCommand(NmtCommand cs) noexcept override;
2070 
2077  void OnHeartbeat(uint8_t id, bool occurred) noexcept override;
2078 
2086  void OnState(uint8_t id, NmtState st) noexcept override;
2087 
2094  void OnSync(uint8_t cnt, const time_point& t) noexcept override;
2095 
2102  void OnSyncError(uint16_t eec, uint8_t er) noexcept override;
2103 
2110  void OnTime(const ::std::chrono::system_clock::time_point& abs_time) noexcept
2111  override;
2112 
2119  void OnEmcy(uint8_t id, uint16_t eec, uint8_t er,
2120  uint8_t msef[5]) noexcept override;
2121 
2128  void OnNodeGuarding(uint8_t id, bool occurred) noexcept override;
2129 
2136  void OnBoot(uint8_t id, NmtState st, char es,
2137  const ::std::string& what) noexcept override;
2138 
2145  void OnConfig(uint8_t id) noexcept override;
2146 };
2147 
2148 } // namespace canopen
2149 
2150 } // namespace lely
2151 
2152 #endif // LELY_COCPP_MASTER_HPP_
lely::canopen::AsyncMaster::OnBoot
void OnBoot(::std::function< void(uint8_t, NmtState, char, const ::std::string &)> on_boot)
Definition: master.hpp:2031
lely::canopen::BasicMaster::SubObject
A mutator providing read/write access to a CANopen sub-object in a local object dictionary.
Definition: master.hpp:59
lely::canopen::BasicMaster::AsyncRead
SdoFuture< T > AsyncRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx)
Equivalent to AsyncRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1363
lely::canopen::BasicMaster::ConstSubObject
An accessor providing read-only access to a CANopen sub-object in a local object dictionary.
Definition: master.hpp:273
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const uint8_t *begin, const uint8_t *end, F &&con, ::std::error_code &ec)
Equivalent to SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t *begin, const uint8_t *end,...
Definition: master.hpp:1224
lely::canopen::DriverBase
The abstract driver interface for a remote CANopen node.
Definition: driver.hpp:36
lely::canopen::Node::OnCanError
void OnCanError(::std::function< void(io::CanError)> on_can_error)
Registers the function to be invoked when an error is detected on the CAN bus.
Definition: node.cpp:252
lely::canopen::BasicMaster::operator[]
Object operator[](::std::ptrdiff_t idx) noexcept
Returns a mutator object that provides read/write access to the specified CANopen object in the local...
Definition: master.hpp:611
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const uint8_t *begin, const uint8_t *end, F &&con, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues a series of asynchronous write (SDO download) operations.
Definition: master.hpp:1268
lely::canopen::NmtCommand
NmtCommand
The NMT command specifiers.
Definition: node.hpp:42
ev_exec_t
const struct ev_exec_vtbl *const ev_exec_t
An abstract task executor.
Definition: ev.h:29
lely::canopen::BasicMaster
The CANopen master.
Definition: master.hpp:50
lely::canopen::Device::RpdoRead
typename ::std::enable_if< is_canopen_basic< T >::value, T >::type RpdoRead(uint8_t id, uint16_t idx, uint8_t subidx) const
Reads the value of a sub-object in a remote object dictionary by submitting an SDO upload request to ...
lely::canopen::Node::OnState
void OnState(::std::function< void(uint8_t, NmtState)> on_state)
Registers the function to be invoked when an NMT state change or boot-up event is detected for a remo...
Definition: node.cpp:302
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(uint8_t id, SdoDownloadDcfRequest &req)
Equivalent to SubmitWriteDcf(uint8_t id, SdoDownloadDcfRequest& req, ::std::error_code& ec),...
Definition: master.cpp:200
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const uint8_t *begin, const uint8_t *end, F &&con)
Equivalent to SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t *begin, const uint8_t *end,...
Definition: master.hpp:1212
lely::canopen::BasicMaster::OnConfig
virtual void OnConfig(uint8_t id) noexcept
The function invoked when the 'update configuration' step is reached during the NMT 'boot slave' proc...
Definition: master.cpp:421
lely::io::TimerBase
A reference to an abstract timer.
Definition: timer.hpp:130
lely::canopen::BasicMaster::WriteSignature
void(uint8_t id, uint16_t idx, uint8_t subidx, ::std::error_code ec) WriteSignature
The signature of the callback function invoked on completion of an asynchronous write (SDO download) ...
Definition: master.hpp:566
lely::canopen::BasicMaster::tpdo_event_mutex
TpdoEventMutex tpdo_event_mutex
Definition: master.hpp:1740
lely::canopen::BasicMaster::SubmitUpload
void SubmitUpload(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, bool block, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues an asynchronous SDO upload operation.
Definition: master.hpp:955
lely::canopen::BasicMaster::AsyncBlockRead
SdoFuture< T > AsyncBlockRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx)
Equivalent to AsyncBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1397
node.hpp
lely::canopen::AsyncMaster
An asynchronous CANopen master.
Definition: master.hpp:1957
lely::canopen::BasicMaster::TpdoEventMutex
Definition: master.hpp:525
lely::canopen::AsyncMaster::OnRpdoWrite
void OnRpdoWrite(::std::function< void(uint8_t, uint16_t, uint8_t)> on_rpdo_write)
Definition: master.hpp:1975
lely::canopen::BasicMaster::GetTimeout
::std::chrono::milliseconds GetTimeout() const
Returns the SDO timeout used during the NMT 'boot slave' and 'check configuration' processes.
Definition: master.cpp:186
lely::canopen::BasicMaster::SubObject::Write
SubObject & Write(const void *p, ::std::size_t n)
Writes an OCTET_STRING or DOMAIN value to the sub-object by submitting an SDO download request to the...
Definition: master.hpp:196
lely::canopen::BasicMaster::Erase
void Erase(DriverBase &driver)
Unregisters a driver for a remote CANopen node.
Definition: master.cpp:274
lely::canopen::BasicMaster::DamMpdoEvent
void DamMpdoEvent(int num, uint8_t id, uint16_t idx, uint8_t subidx, T value)
Definition: master.hpp:741
lely::canopen::BasicMaster::AsyncWriteDcf
SdoFuture< void > AsyncWriteDcf(ev_exec_t *exec, uint8_t id, const char *path)
Equivalent to AsyncWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, const ::std::chrono::milli...
Definition: master.hpp:1619
lely::canopen::Device::TpdoWrite
typename ::std::enable_if< is_canopen_basic< T >::value >::type TpdoWrite(uint8_t id, uint16_t idx, uint8_t subidx, T value)
Writes a value to a sub-object in a remote object dictionary by submitting an SDO download request to...
lely::canopen::BasicMaster::Insert
void Insert(DriverBase &driver)
Registers a driver for a remote CANopen node.
Definition: master.cpp:257
lely::error
The type of objects thrown as exceptions to report a system error with an associated error code.
Definition: exception.hpp:54
lely::canopen::BasicMaster::Boot
bool Boot(uint8_t id)
Requests the NMT 'boot slave' process for the specified node.
Definition: master.cpp:91
lely::canopen::BasicMaster::OnState
void OnState(::std::function< void(uint8_t, NmtState)> on_state)
Definition: master.hpp:1691
lely::io::CanNet::on_can_state
virtual void on_can_state(CanState new_state, CanState old_state) noexcept
The function invoked when a CAN bus state change is detected.
Definition: can_net.hpp:191
lely::canopen::BasicMaster::Error
void Error(uint8_t id)
Indicates the occurrence of an error event on a remote node and triggers the error handling process (...
Definition: master.cpp:150
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const uint8_t *begin, const uint8_t *end, F &&con, const ::std::chrono::milliseconds &timeout)
Equivalent to SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t *begin, const uint8_t *end,...
Definition: master.hpp:1237
lely::io::CanChannelBase
A reference to an abstract CAN channel.
Definition: can.hpp:430
lely::canopen::Node::OnCanState
void OnCanState(::std::function< void(io::CanState, io::CanState)> on_can_state)
Registers the function to be invoked when a CAN bus state change is detected.
Definition: node.cpp:245
lely::canopen::BasicMaster::SubObject::WriteEvent
void WriteEvent(::std::error_code &ec) noexcept
Checks if the sub-object can be mapped into a PDO and, if so, triggers the transmission of every acyc...
Definition: master.hpp:248
lely::canopen::BasicMaster::TpdoMapped::operator[]
ConstObject operator[](uint16_t idx) const noexcept
Returns an accessor object that provides read-only access to the specified TPDO-mapped object in the ...
Definition: master.hpp:512
lely::canopen::AsyncMaster::OnCommand
void OnCommand(::std::function< void(NmtCommand)> on_command)
Definition: master.hpp:1981
lely::canopen::BasicMaster::SubmitWrite
void SubmitWrite(uint8_t id, SdoDownloadRequest< T > &req, ::std::error_code &ec)
Queues an asynchronous write (SDO download) operation.
Definition: master.hpp:994
lely::canopen::Node::OnHeartbeat
void OnHeartbeat(::std::function< void(uint8_t, bool)> on_heartbeat)
Registers the function to be invoked when a heartbeat timeout event occurs or is resolved.
Definition: node.cpp:296
lely::canopen::BasicMaster::OnNodeGuarding
void OnNodeGuarding(::std::function< void(uint8_t, bool)> on_node_guarding)
Registers the function invoked when a node guarding timeout event occurs or is resolved.
Definition: master.cpp:286
lely::canopen::Node::OnTime
void OnTime(::std::function< void(const ::std::chrono::system_clock::time_point &)> on_time)
Registers the function to be invoked when a TIME message is received.
Definition: node.cpp:362
lely::canopen::BasicMaster::OnRpdoWrite
void OnRpdoWrite(::std::function< void(uint8_t, uint16_t, uint8_t)> on_rpdo_write)
Definition: master.hpp:1673
lely::canopen::BasicMaster::AsyncUpload
SdoFuture< T > AsyncUpload(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, bool block, const ::std::chrono::milliseconds &timeout)
Queues an asynchronous SDO upload operation and creates a future which becomes ready once the request...
Definition: master.hpp:1448
lely::io::CanError
CanError
The error flags of a CAN bus, which are not mutually exclusive.
Definition: err.hpp:47
lely::canopen::BasicMaster::SubmitRead
void SubmitRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, ::std::error_code &ec)
Equivalent to SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:818
lely::canopen::SdoDownloadDcfRequest
A series of SDO download (i.e., write) requests corresponding to the entries in a concise DCF.
Definition: sdo.hpp:318
lely::canopen::detail::SdoRequestBase::idx
uint16_t idx
The object index.
Definition: sdo.hpp:193
lely::canopen::BasicMaster::SubmitRead
void SubmitRead(uint8_t id, SdoUploadRequest< T > &req, ::std::error_code &ec)
Queues an asynchronous read (SDO upload) operation.
Definition: master.hpp:786
lely::io::CanState
CanState
The states of a CAN node, depending on the TX/RX error count.
Definition: err.hpp:33
lely::canopen::BasicMaster::AsyncRead
SdoFuture< T > AsyncRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, const ::std::chrono::milliseconds &timeout)
Queues an asynchronous read (SDO upload) operation and creates a future which becomes ready once the ...
Definition: master.hpp:1385
lely::canopen::BasicMaster::SubmitBlockWrite
void SubmitBlockWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, ::std::error_code &ec)
Equivalent to SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1095
lely::canopen::BasicMaster::OnBoot
void OnBoot(::std::function< void(uint8_t, NmtState, char, const ::std::string &)> on_boot)
Registers the function invoked when the NMT 'boot slave' process completes.
Definition: master.cpp:293
lely::canopen::BasicMaster::TpdoMapped
A mutator providing read/write access to TPDO-mapped objects in a remote object dictionary.
Definition: master.hpp:482
lely::canopen::BasicMaster::OnCommand
void OnCommand(::std::function< void(NmtCommand)> on_command)
Definition: master.hpp:1679
lely::canopen::BasicMaster::OnSyncError
void OnSyncError(::std::function< void(uint16_t, uint8_t)> on_sync_error)
Definition: master.hpp:1703
lely::canopen::BasicMaster::SubObject::Read
T Read() const
Reads the value of the sub-object by submitting an SDO upload request to the local object dictionary.
Definition: master.hpp:111
lely::io::CanNet::lock
void lock() final
Blocks until a lock can be obtained for the current execution agent (thread, process,...
Definition: can_net.hpp:104
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const char *path, F &&con, ::std::error_code &ec)
Equivalent to SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con,...
Definition: master.hpp:1302
lely::canopen::Device::id
uint8_t id() const noexcept
Returns the node-ID.
Definition: device.cpp:193
lely::canopen::BasicMaster::RpdoMapped
An accessor providing read-only access to TPDO-mapped objects in a remote object dictionary.
Definition: master.hpp:451
lely::canopen::BasicMaster::TpdoEventMutex::unlock
void unlock() override
Releases the lock held by the execution agent. Throws no exceptions.
Definition: master.cpp:76
lely::canopen::BasicMaster::AsyncWrite
SdoFuture< void > AsyncWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value)
Equivalent to AsyncWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1471
lely::canopen::AsyncMaster::OnHeartbeat
void OnHeartbeat(::std::function< void(uint8_t, bool)> on_heartbeat)
Definition: master.hpp:1987
lely::canopen::BasicMaster::RpdoRtr
void RpdoRtr(int num=0) noexcept
Definition: master.cpp:172
lely::canopen::BasicMaster::AsyncBlockWrite
SdoFuture< void > AsyncBlockWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, const ::std::chrono::milliseconds &timeout)
Queues an asynchronous write (SDO block download) operation and creates a future which becomes ready ...
Definition: master.hpp:1536
lely::canopen::BasicMaster::SubObject::Read
T Read(::std::error_code &ec) const
Reads the value of the sub-object by submitting an SDO upload request to the local object dictionary.
Definition: master.hpp:129
lely::canopen::BasicMaster::SubmitDownload
void SubmitDownload(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, bool block, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues an asynchronous SDO download operation.
Definition: master.hpp:1170
lely::canopen::Node::OnCommand
void OnCommand(::std::function< void(NmtCommand)> on_command)
Registers the function to be invoked when an NMT command is received from the master.
Definition: node.cpp:290
lely::io::CanNet::on_can_error
virtual void on_can_error(CanError error) noexcept
The function invoked when an error is detected on the CAN bus.
Definition: can_net.hpp:208
lely::canopen::BasicMaster::AsyncWriteDcf
SdoFuture< void > AsyncWriteDcf(ev_exec_t *exec, uint8_t id, const uint8_t *begin, const uint8_t *end)
Equivalent to AsyncWriteDcf(ev_exec_t* exec, uint8_t id, const uint8_t* begin, const uint8_t* end,...
Definition: master.hpp:1586
lely::canopen::BasicMaster::OnHeartbeat
void OnHeartbeat(::std::function< void(uint8_t, bool)> on_heartbeat)
Definition: master.hpp:1685
lely::canopen::BasicMaster::CancelSdo
void CancelSdo(uint8_t id=0)
Aborts any ongoing or pending SDO requests for the specified slave.
Definition: master.cpp:494
lely::canopen::BasicMaster::OnTime
void OnTime(::std::function< void(const ::std::chrono::system_clock::time_point &)> on_time)
Definition: master.hpp:1709
lely::ev::Future
A future.
Definition: future.hpp:50
lely::canopen::BasicMaster::SubmitBlockWrite
void SubmitBlockWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues an asynchronous write (SDO block download) operation.
Definition: master.hpp:1141
lely::canopen::BasicMaster::TpdoMapped
TpdoMapped TpdoMapped(uint8_t id) noexcept
Returns a mutator object that provides read/write access to TPDO-mapped objects in the remote object ...
Definition: master.hpp:656
lely::canopen::BasicMaster::SubObject::WriteEvent
void WriteEvent()
Checks if the sub-object can be mapped into a PDO and, if so, triggers the transmission of every acyc...
Definition: master.hpp:230
lely::canopen::Node::OnSyncError
void OnSyncError(::std::function< void(uint16_t, uint8_t)> on_sync_error)
Registers the function to be invoked when the data length of a received SYNC message does not match.
Definition: node.cpp:352
lely::canopen::AsyncMaster::OnSync
void OnSync(::std::function< void(uint8_t, const time_point &)> on_sync)
Definition: master.hpp:1999
lely::canopen::BasicMaster::RpdoMapped::operator[]
ConstObject operator[](uint16_t idx) const noexcept
Returns an accessor object that provides read-only access to the specified RPDO-mapped object in the ...
Definition: master.hpp:466
lely::canopen::Node::OnEmcy
void OnEmcy(::std::function< void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy)
Registers the function to be invoked when an EMCY message is received.
Definition: node.cpp:374
lely::canopen::BasicMaster::SubmitWrite
void SubmitWrite(uint8_t id, SdoDownloadRequest< T > &req)
Equivalent to SubmitWrite(uint8_t id, SdoDownloadRequest<T>& req, ::std::error_code& ec),...
Definition: master.hpp:978
lely::canopen::BasicMaster::ConstObject::operator[]
ConstSubObject operator[](uint8_t subidx) const noexcept
Returns an accessor object that provides read-only access to the specified CANopen sub-object in the ...
Definition: master.hpp:429
lely::canopen::BasicMaster::SubObject::operator=
SubObject & operator=(T &&value)
Sets the value of the sub-object.
Definition: master.hpp:81
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const char *path, F &&con, const ::std::chrono::milliseconds &timeout)
Equivalent to SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con,...
Definition: master.hpp:1314
lely::canopen::BasicMaster::ConfigResult
void ConfigResult(uint8_t id, ::std::error_code ec) noexcept
Reports the result of the 'update configuration' step to the NMT service.
Definition: master.cpp:443
lely::canopen::BasicMaster::BasicMaster
BasicMaster(ev_exec_t *exec, io::TimerBase &timer, io::CanChannelBase &chan, const ::std::string &dcf_txt, const ::std::string &dcf_bin="", uint8_t id=0xff)
Creates a new CANopen master.
Definition: master.cpp:81
lely::canopen::BasicMaster::ConstObject
An accessor providing read-only access to a CANopen object in a local object dictionary.
Definition: master.hpp:411
lely::canopen::BasicMaster::SubmitRead
void SubmitRead(uint8_t id, SdoUploadRequest< T > &req)
Equivalent to SubmitRead(uint8_t id, SdoUploadRequest<T>& req, ::std::error_code& ec),...
Definition: master.hpp:770
lely::canopen::BasicMaster::SubObject::Write
SubObject & Write(T &&value, ::std::error_code &ec)
Writes a value to the sub-object by submitting an SDO download request to the local object dictionary...
Definition: master.hpp:174
lely::canopen::BasicMaster::SubmitWrite
void SubmitWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, const ::std::chrono::milliseconds &timeout)
Equivalent to SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1040
lely::canopen::BasicMaster::SubmitBlockWrite
void SubmitBlockWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, const ::std::chrono::milliseconds &timeout)
Equivalent to SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1108
lely::canopen::Device::TpdoWriteEvent
void TpdoWriteEvent(uint8_t id, uint16_t idx, uint8_t subidx)
Triggers the transmission of every event-driven, asynchronous Transmit-PDO which is mapped into the s...
Definition: device.cpp:796
lely::canopen::BasicMaster::SubmitWrite
void SubmitWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues an asynchronous write (SDO download) operation.
Definition: master.hpp:1068
lely::canopen::BasicMaster::OnCanState
void OnCanState(::std::function< void(io::CanState, io::CanState)> on_can_state)
Definition: master.hpp:1661
lely::canopen::AsyncMaster::OnConfig
void OnConfig(uint8_t id) noexcept override
The default implementation queues a notification for the driver registered for node id.
Definition: master.cpp:621
lely::canopen::Node
The base class for CANopen nodes.
Definition: node.hpp:116
lely::canopen::Node::GetExecutor
ev::Executor GetExecutor() const noexcept
Returns the executor used to process I/O and CANopen events.
Definition: node.cpp:159
lely::canopen::BasicMaster::OnEmcy
void OnEmcy(::std::function< void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy)
Definition: master.hpp:1716
lely::canopen::BasicMaster::SubmitWrite
void SubmitWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con)
Equivalent to SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1014
lely::canopen::BasicMaster::AsyncBlockWrite
SdoFuture< void > AsyncBlockWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value)
Equivalent to AsyncBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1508
lely::canopen::BasicMaster::Object::operator[]
SubObject operator[](uint8_t subidx) noexcept
Returns a mutator object that provides read/write access to the specified CANopen sub-object in the l...
Definition: master.hpp:375
lely::canopen::BasicMaster::IsReady
bool IsReady(uint8_t id) const
Returns true if the remote node is ready (i.e., the NMT 'boot slave' process has successfully complet...
Definition: master.cpp:117
lely::canopen::NmtState
NmtState
The NMT states.
Definition: node.hpp:56
lely::canopen::SdoError
The type of exception thrown when an SDO abort code is received.
Definition: sdo_error.hpp:121
lely::canopen::Node::OnSync
void OnSync(::std::function< void(uint8_t, const time_point &)> on_sync)
Registers the function to be invoked when a SYNC message is sent/received.
Definition: node.cpp:342
lely::canopen::BasicMaster::SubmitBlockWrite
void SubmitBlockWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con)
Equivalent to SubmitBlockWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1082
lely::canopen::BasicMaster::AsyncDeconfig
ev::Future<::std::size_t, void > AsyncDeconfig()
Queues the DriverBase::OnDeconfig() method for all registered drivers and creates a future which beco...
Definition: master.cpp:135
lely::canopen::BasicMaster::ConstSubObject::Read
T Read(::std::error_code &ec) const
Reads the value of the sub-object by submitting an SDO upload request to the local object dictionary.
Definition: master.hpp:325
lely::canopen::Device::TpdoRead
typename ::std::enable_if< is_canopen_basic< T >::value, T >::type TpdoRead(uint8_t id, uint16_t idx, uint8_t subidx) const
Submits an SDO upload request to a TPDO-mapped sub-object in the local object dictionary,...
lely::canopen::BasicMaster::AsyncDownload
SdoFuture< void > AsyncDownload(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, bool block, const ::std::chrono::milliseconds &timeout)
Queues an asynchronous SDO download operation and creates a future which becomes ready once the reque...
Definition: master.hpp:1562
lely::canopen::AsyncMaster::OnNodeGuarding
void OnNodeGuarding(::std::function< void(uint8_t, bool)> on_node_guarding)
Definition: master.hpp:2025
lely::canopen::BasicMaster::SubmitBlockRead
void SubmitBlockRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, const ::std::chrono::milliseconds &timeout)
Equivalent to SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:897
lely::canopen::BasicMaster::operator[]
ConstObject operator[](::std::ptrdiff_t idx) const noexcept
Returns an accessor object that provides read-only access to the specified CANopen object in the loca...
Definition: master.hpp:626
lely::canopen::BasicMaster::ReadSignature
void(uint8_t id, uint16_t idx, uint8_t subidx, ::std::error_code ec, T value) ReadSignature
The signature of the callback function invoked on completion of an asynchronous read (SDO upload) ope...
Definition: master.hpp:551
lely::canopen::AsyncMaster::OnEmcy
void OnEmcy(::std::function< void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy)
Definition: master.hpp:2018
lely::canopen::BasicMaster::SubmitRead
void SubmitRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues an asynchronous read (SDO upload) operation.
Definition: master.hpp:857
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const char *path, F &&con)
Equivalent to SubmitWriteDcf(ev_exec_t* exec, uint8_t id, const char* path, F&& con,...
Definition: master.hpp:1291
lely::canopen::AsyncMaster::OnTime
void OnTime(::std::function< void(const ::std::chrono::system_clock::time_point &)> on_time)
Definition: master.hpp:2011
lely::canopen::BasicMaster::OnSync
void OnSync(::std::function< void(uint8_t, const time_point &)> on_sync)
Definition: master.hpp:1697
lely::canopen::BasicMaster::Impl_
The internal implementation of the CANopen master.
Definition: master.cpp:44
lely::canopen::BasicMaster::GetSdo
Sdo * GetSdo(uint8_t id)
Returns a pointer to the default client-SDO service for the given node.
Definition: master.cpp:473
lely::canopen::BasicMaster::SetTimeout
void SetTimeout(const ::std::chrono::milliseconds &timeout)
Sets the SDO timeout used during the NMT 'boot slave' and 'check configuration' processes.
Definition: master.cpp:193
lely::canopen::AsyncMaster::OnCanState
void OnCanState(::std::function< void(io::CanState, io::CanState)> on_can_state)
Definition: master.hpp:1963
lely::canopen::SdoErrc::NO_SDO
@ NO_SDO
Resource not available: SDO connection.
lely::canopen::Node::SetTime
void SetTime()
Updates the CAN network time.
Definition: node.cpp:415
lely::canopen::BasicMaster::SubmitBlockRead
void SubmitBlockRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, ::std::error_code &ec)
Equivalent to SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:884
lely::canopen::BasicMaster::SubmitBlockRead
void SubmitBlockRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con)
Equivalent to SubmitBlockRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:871
lely::canopen::Device::Write
typename ::std::enable_if< is_canopen< T >::value >::type Write(uint16_t idx, uint8_t subidx, const T &value)
Submits an SDO download request to the local object dictionary.
lely::canopen::BasicMaster::Command
void Command(NmtCommand cs, uint8_t id=0)
Issues an NMT command to a slave.
Definition: master.cpp:164
sdo.hpp
lely::canopen::AsyncMaster::OnCanError
void OnCanError(::std::function< void(io::CanError)> on_can_error)
Definition: master.hpp:1969
lely::canopen::BasicMaster::ConstSubObject::Read
T Read() const
Reads the value of the sub-object by submitting an SDO upload request to the local object dictionary.
Definition: master.hpp:305
lely::canopen::SdoUploadRequest
An SDO upload (i.e., read) request.
Definition: sdo.hpp:361
lely::canopen::BasicMaster::BasicMaster
BasicMaster(io::TimerBase &timer, io::CanChannelBase &chan, const ::std::string &dcf_txt, const ::std::string &dcf_bin="", uint8_t id=0xff)
Creates a new CANopen master.
Definition: master.hpp:593
lely::canopen::BasicMaster::SubObject::Write
SubObject & Write(T &&value)
Writes a value to the sub-object by submitting an SDO download request to the local object dictionary...
Definition: master.hpp:149
lely::canopen::BasicMaster::RpdoMapped
RpdoMapped RpdoMapped(uint8_t id) const noexcept
Returns an accessor object that provides read-only access to RPDO-mapped objects in the remote object...
Definition: master.hpp:641
lely::canopen::BasicMaster::TpdoMapped::operator[]
Object operator[](uint16_t idx) noexcept
Returns a mutator object that provides read/write access to the specified PDO-mapped object in the re...
Definition: master.hpp:497
lely::canopen::BasicMaster::SubmitRead
void SubmitRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, const ::std::chrono::milliseconds &timeout)
Equivalent to SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:831
lely::canopen::BasicMaster::OnCanError
void OnCanError(::std::function< void(io::CanError)> on_can_error)
Definition: master.hpp:1667
lely::canopen::BasicMaster::IsConfig
bool IsConfig(uint8_t id) const
Returns true if the remote node is configuring (i.e., the 'update configuration' step of the NMT 'boo...
Definition: master.cpp:462
lely::canopen::BasicMaster::TpdoEventMutex::lock
void lock() override
Blocks until a lock can be obtained for the current execution agent (thread, process,...
Definition: master.cpp:70
lely::canopen::Device::Read
typename ::std::enable_if< is_canopen< T >::value, T >::type Read(uint16_t idx, uint8_t subidx) const
Submits an SDO upload request to the local object dictionary.
lely::canopen::AsyncMaster::OnSyncError
void OnSyncError(::std::function< void(uint16_t, uint8_t)> on_sync_error)
Definition: master.hpp:2005
lely::canopen::detail::SdoRequestBase::subidx
uint8_t subidx
The object sub-index.
Definition: sdo.hpp:195
lely::canopen::BasicMaster::SubObject::Write
SubObject & Write(const void *p, ::std::size_t n, ::std::error_code &ec)
Writes an OCTET_STRING or DOMAIN value to the sub-object by submitting an SDO download request to the...
Definition: master.hpp:214
lely::canopen::BasicMaster::SubmitBlockRead
void SubmitBlockRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues an asynchronous read (SDO block upload) operation.
Definition: master.hpp:928
lely::canopen::Device::WriteEvent
void WriteEvent(uint16_t idx, uint8_t subidx)
Checks if the specified sub-object in the local object dictionary can be mapped into a PDO and,...
Definition: device.cpp:575
lely::canopen::BasicMaster::SubmitWriteDcf
void SubmitWriteDcf(ev_exec_t *exec, uint8_t id, const char *path, F &&con, const ::std::chrono::milliseconds &timeout, ::std::error_code &ec)
Queues a series of asynchronous write (SDO download) operations.
Definition: master.hpp:1341
lely::canopen::AsyncMaster::OnState
void OnState(::std::function< void(uint8_t, NmtState)> on_state)
Definition: master.hpp:1993
lely::canopen::BasicMaster::AsyncBlockRead
SdoFuture< T > AsyncBlockRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, const ::std::chrono::milliseconds &timeout)
Queues an asynchronous read (SDO block upload) operation and creates a future which becomes ready onc...
Definition: master.hpp:1423
lely::canopen::SdoDownloadRequest
An SDO download (i.e., write) request.
Definition: sdo.hpp:281
lely::canopen::BasicMaster::Object
A mutator providing read/write access to a CANopen object in a local object dictionary.
Definition: master.hpp:358
lely::canopen::BasicMaster::SubmitRead
void SubmitRead(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, F &&con)
Equivalent to SubmitRead(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:806
lely::canopen::Node::TpdoEventMutex
A recursive mutex-like object that can be used to postpone the transmission of acyclic and event-driv...
Definition: node.hpp:463
lely::canopen::Sdo
A Client-SDO queue.
Definition: sdo.hpp:588
lely::canopen::BasicMaster::TpdoEvent
void TpdoEvent(int num=0) noexcept
Definition: master.cpp:179
lely::canopen::BasicMaster::SubmitWrite
void SubmitWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, F &&con, ::std::error_code &ec)
Equivalent to SubmitWrite(ev_exec_t* exec, uint8_t id, uint16_t idx, uint8_t subidx,...
Definition: master.hpp:1027
lely::canopen::BasicMaster::AsyncWrite
SdoFuture< void > AsyncWrite(ev_exec_t *exec, uint8_t id, uint16_t idx, uint8_t subidx, T &&value, const ::std::chrono::milliseconds &timeout)
Queues an asynchronous write (SDO download) operation and creates a future which becomes ready once t...
Definition: master.hpp:1495
lely::canopen::BasicMaster::Object::operator[]
ConstSubObject operator[](uint8_t subidx) const noexcept
Returns an accessor object that provides read-only access to the specified CANopen sub-object in the ...
Definition: master.hpp:391