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
35namespace lely {
36
37namespace canopen {
38
39class DriverBase;
40
50class 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>
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:
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
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
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
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
641 RpdoMapped(uint8_t id) const noexcept {
642 return {this, id};
643 }
644
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
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
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>
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>
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>
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>
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>
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
1957class 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_
An asynchronous CANopen master.
Definition: master.hpp:1957
void OnCanState(::std::function< void(io::CanState, io::CanState)> on_can_state)
Definition: master.hpp:1963
void OnTime(::std::function< void(const ::std::chrono::system_clock::time_point &)> on_time)
Definition: master.hpp:2011
void OnCanError(::std::function< void(io::CanError)> on_can_error)
Definition: master.hpp:1969
void OnNodeGuarding(::std::function< void(uint8_t, bool)> on_node_guarding)
Definition: master.hpp:2025
void OnEmcy(::std::function< void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy)
Definition: master.hpp:2018
void OnConfig(uint8_t id) noexcept override
The default implementation queues a notification for the driver registered for node id.
Definition: master.cpp:621
void OnBoot(::std::function< void(uint8_t, NmtState, char, const ::std::string &)> on_boot)
Definition: master.hpp:2031
void OnState(::std::function< void(uint8_t, NmtState)> on_state)
Definition: master.hpp:1993
void OnSyncError(::std::function< void(uint16_t, uint8_t)> on_sync_error)
Definition: master.hpp:2005
void OnRpdoWrite(::std::function< void(uint8_t, uint16_t, uint8_t)> on_rpdo_write)
Definition: master.hpp:1975
void OnCommand(::std::function< void(NmtCommand)> on_command)
Definition: master.hpp:1981
void OnSync(::std::function< void(uint8_t, const time_point &)> on_sync)
Definition: master.hpp:1999
void OnHeartbeat(::std::function< void(uint8_t, bool)> on_heartbeat)
Definition: master.hpp:1987
An accessor providing read-only access to a CANopen object in a local object dictionary.
Definition: master.hpp:411
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
An accessor providing read-only access to a CANopen sub-object in a local object dictionary.
Definition: master.hpp:273
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
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
A mutator providing read/write access to a CANopen object in a local object dictionary.
Definition: master.hpp:358
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
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
An accessor providing read-only access to TPDO-mapped objects in a remote object dictionary.
Definition: master.hpp:451
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
A mutator providing read/write access to a CANopen sub-object in a local object dictionary.
Definition: master.hpp:59
SubObject & operator=(T &&value)
Sets the value of the sub-object.
Definition: master.hpp:81
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
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
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
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
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
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
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
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
void lock() override
Blocks until a lock can be obtained for the current execution agent (thread, process,...
Definition: master.cpp:70
void unlock() override
Releases the lock held by the execution agent. Throws no exceptions.
Definition: master.cpp:76
A mutator providing read/write access to TPDO-mapped objects in a remote object dictionary.
Definition: master.hpp:482
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
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
The CANopen master.
Definition: master.hpp:50
void OnState(::std::function< void(uint8_t, NmtState)> on_state)
Definition: master.hpp:1691
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
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
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
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
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
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
void TpdoEvent(int num=0) noexcept
Definition: master.cpp:179
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
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
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
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
void SubmitWriteDcf(uint8_t id, SdoDownloadDcfRequest &req)
Equivalent to SubmitWriteDcf(uint8_t id, SdoDownloadDcfRequest& req, ::std::error_code& ec),...
Definition: master.cpp:200
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
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
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
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
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
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
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
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
void OnTime(::std::function< void(const ::std::chrono::system_clock::time_point &)> on_time)
Definition: master.hpp:1709
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
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
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
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
void RpdoRtr(int num=0) noexcept
Definition: master.cpp:172
void OnHeartbeat(::std::function< void(uint8_t, bool)> on_heartbeat)
Definition: master.hpp:1685
void Command(NmtCommand cs, uint8_t id=0)
Issues an NMT command to a slave.
Definition: master.cpp:164
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
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
void OnCanState(::std::function< void(io::CanState, io::CanState)> on_can_state)
Definition: master.hpp:1661
void Erase(DriverBase &driver)
Unregisters a driver for a remote CANopen node.
Definition: master.cpp:274
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
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
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
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
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
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
void Insert(DriverBase &driver)
Registers a driver for a remote CANopen node.
Definition: master.cpp:257
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
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
bool Boot(uint8_t id)
Requests the NMT 'boot slave' process for the specified node.
Definition: master.cpp:91
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
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
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
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
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
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
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
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
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
::std::chrono::milliseconds GetTimeout() const
Returns the SDO timeout used during the NMT 'boot slave' and 'check configuration' processes.
Definition: master.cpp:186
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
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
void OnEmcy(::std::function< void(uint8_t, uint16_t, uint8_t, uint8_t[5])> on_emcy)
Definition: master.hpp:1716
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
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
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
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
void OnCanError(::std::function< void(io::CanError)> on_can_error)
Definition: master.hpp:1667
TpdoEventMutex tpdo_event_mutex
Definition: master.hpp:1740
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
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
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
void CancelSdo(uint8_t id=0)
Aborts any ongoing or pending SDO requests for the specified slave.
Definition: master.cpp:494
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
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
void OnSync(::std::function< void(uint8_t, const time_point &)> on_sync)
Definition: master.hpp:1697
void SubmitRead(uint8_t id, SdoUploadRequest< T > &req, ::std::error_code &ec)
Queues an asynchronous read (SDO upload) operation.
Definition: master.hpp:786
void OnRpdoWrite(::std::function< void(uint8_t, uint16_t, uint8_t)> on_rpdo_write)
Definition: master.hpp:1673
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
void DamMpdoEvent(int num, uint8_t id, uint16_t idx, uint8_t subidx, T value)
Definition: master.hpp:741
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
void SubmitWrite(uint8_t id, SdoDownloadRequest< T > &req, ::std::error_code &ec)
Queues an asynchronous write (SDO download) operation.
Definition: master.hpp:994
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
void OnCommand(::std::function< void(NmtCommand)> on_command)
Definition: master.hpp:1679
Sdo * GetSdo(uint8_t id)
Returns a pointer to the default client-SDO service for the given node.
Definition: master.cpp:473
void OnSyncError(::std::function< void(uint16_t, uint8_t)> on_sync_error)
Definition: master.hpp:1703
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
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
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
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.
Definition: device.cpp:231
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...
Definition: device.cpp:635
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
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.
Definition: device.cpp:262
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,...
Definition: device.cpp:613
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 ...
Definition: device.cpp:591
uint8_t id() const noexcept
Returns the node-ID.
Definition: device.cpp:193
The abstract driver interface for a remote CANopen node.
Definition: driver.hpp:36
A recursive mutex-like object that can be used to postpone the transmission of acyclic and event-driv...
Definition: node.hpp:463
The base class for CANopen nodes.
Definition: node.hpp:116
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
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
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
void SetTime()
Updates the CAN network time.
Definition: node.cpp:415
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
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
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
ev::Executor GetExecutor() const noexcept
Returns the executor used to process I/O and CANopen events.
Definition: node.cpp:159
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
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
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
A series of SDO download (i.e., write) requests corresponding to the entries in a concise DCF.
Definition: sdo.hpp:318
An SDO download (i.e., write) request.
Definition: sdo.hpp:281
The type of exception thrown when an SDO abort code is received.
Definition: sdo_error.hpp:121
An SDO upload (i.e., read) request.
Definition: sdo.hpp:361
A Client-SDO queue.
Definition: sdo.hpp:588
uint16_t idx
The object index.
Definition: sdo.hpp:193
uint8_t subidx
The object sub-index.
Definition: sdo.hpp:195
The type of objects thrown as exceptions to report a system error with an associated error code.
Definition: exception.hpp:54
A future.
Definition: future.hpp:384
A reference to an abstract CAN channel.
Definition: can.hpp:430
void lock() final
Blocks until a lock can be obtained for the current execution agent (thread, process,...
Definition: can_net.hpp:104
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
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
A reference to an abstract timer.
Definition: timer.hpp:130
CanError
The error flags of a CAN bus, which are not mutually exclusive.
Definition: err.hpp:47
CanState
The states of a CAN node, depending on the TX/RX error count.
Definition: err.hpp:33
const struct ev_exec_vtbl *const ev_exec_t
An abstract task executor.
Definition: ev.h:29
NmtState
The NMT states.
Definition: node.hpp:56
@ NO_SDO
Resource not available: SDO connection.
NmtCommand
The NMT command specifiers.
Definition: node.hpp:42
This header file is part of the C++ CANopen application library; it contains the CANopen node declara...
This header file is part of the C++ CANopen master library; it contains the Client-SDO queue declarat...
The internal implementation of the CANopen master.
Definition: master.cpp:44