Lely core libraries  2.3.4
csdo.hpp
Go to the documentation of this file.
1 
23 #ifndef LELY_CO_CSDO_HPP_
24 #define LELY_CO_CSDO_HPP_
25 
26 #if !defined(__cplusplus) || LELY_NO_CXX
27 #error "include <lely/co/csdo.h> for the C interface"
28 #endif
29 
30 #include <lely/can/net.hpp>
31 #include <lely/co/csdo.h>
32 #include <lely/co/val.hpp>
33 
34 #include <string>
35 #include <vector>
36 
37 namespace lely {
38 
39 template <class>
40 struct COCSDOUpCon;
41 
42 inline int
43 dnReq(CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
44  size_t n, co_csdo_dn_con_t* con, void* data) noexcept {
45  return co_dev_dn_req(&dev, idx, subidx, ptr, n, con, data);
46 }
47 
48 template <class F>
49 inline int
50 dnReq(CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
51  size_t n, F* f) noexcept {
52  return dnReq(dev, idx, subidx, ptr, n,
54  static_cast<void*>(f));
55 }
56 
57 template <class T, typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
58 inline int
59 dnReq(CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
60  size_t n, T* t) noexcept {
61  return dnReq(dev, idx, subidx, ptr, n,
62  &c_mem_call<co_csdo_dn_con_t*, T, M>::function,
63  static_cast<void*>(t));
64 }
65 
66 template <co_unsigned16_t N>
67 inline int
68 dnReq(CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
69  const COVal<N>& val, co_csdo_dn_con_t* con, void* data) noexcept {
70  return co_dev_dn_val_req(&dev, idx, subidx, N, &val, con, data);
71 }
72 
73 template <co_unsigned16_t N, class F>
74 inline int
75 dnReq(CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
76  const COVal<N>& val, F* f) noexcept {
77  return dnReq<N>(dev, idx, subidx, val,
78  &c_obj_call<co_csdo_dn_con_t*, F>::function,
79  static_cast<void*>(f));
80 }
81 
82 template <co_unsigned16_t N, class T,
83  typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
84 inline int
85 dnReq(CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
86  const COVal<N>& val, T* t) noexcept {
87  return dnReq<N>(dev, idx, subidx, val,
88  &c_mem_call<co_csdo_dn_con_t*, T, M>::function,
89  static_cast<void*>(t));
90 }
91 
92 inline int
93 upReq(const CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
94  co_csdo_up_con_t* con, void* data) noexcept {
95  return co_dev_up_req(&dev, idx, subidx, con, data);
96 }
97 
98 template <class T, typename COCSDOUpCon<T>::type M>
99 inline int
100 upReq(const CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
101  void* data) noexcept {
102  return upReq(dev, idx, subidx, &COCSDOUpCon<T>::template function<M>, data);
103 }
104 
105 template <class T, class F>
106 inline int
107 upReq(const CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
108  F* f) noexcept {
109  return upReq(dev, idx, subidx,
110  &COCSDOUpCon<T>::template function<
111  &c_obj_call<typename COCSDOUpCon<T>::type, F>::function>,
112  static_cast<void*>(f));
113 }
114 
115 template <class T, class C,
116  typename c_mem_fn<typename COCSDOUpCon<T>::type, C>::type M>
117 inline int
118 upReq(const CODev& dev, co_unsigned16_t idx, co_unsigned8_t subidx,
119  C* obj) noexcept {
120  return upReq(dev, idx, subidx,
121  &COCSDOUpCon<T>::template function<
122  &c_mem_call<typename COCSDOUpCon<T>::type, C, M>::function>,
123  static_cast<void*>(obj));
124 }
125 
127 template <>
129  typedef __co_csdo value_type;
130  typedef value_type& reference;
131  typedef const value_type& const_reference;
132  typedef value_type* pointer;
133  typedef const value_type* const_pointer;
134 
135  static void*
136  alloc() noexcept {
137  return __co_csdo_alloc();
138  }
139 
140  static void
141  free(void* ptr) noexcept {
142  __co_csdo_free(ptr);
143  }
144 
145  static pointer
146  init(pointer p, CANNet* net, CODev* dev, co_unsigned8_t num) noexcept {
147  return __co_csdo_init(p, net, dev, num);
148  }
149 
150  static void
151  fini(pointer p) noexcept {
152  __co_csdo_fini(p);
153  }
154 };
155 
157 class COCSDO : public incomplete_c_type<__co_csdo> {
159 
160  public:
161  COCSDO(CANNet* net, CODev* dev, co_unsigned8_t num) : c_base(net, dev, num) {}
162 
163  int
164  start() noexcept {
165  return co_csdo_start(this);
166  }
167 
168  void
169  stop() noexcept {
170  co_csdo_stop(this);
171  }
172 
173  CANNet*
174  getNet() const noexcept {
175  return co_csdo_get_net(this);
176  }
177 
178  CODev*
179  getDev() const noexcept {
180  return co_csdo_get_dev(this);
181  }
182 
183  co_unsigned8_t
184  getNum() const noexcept {
185  return co_csdo_get_num(this);
186  }
187 
188  const co_sdo_par&
189  getPar() const noexcept {
190  return *co_csdo_get_par(this);
191  }
192 
193  int
194  getTimeout() const noexcept {
195  return co_csdo_get_timeout(this);
196  }
197 
198  void
199  setTimeout(int timeout) noexcept {
200  co_csdo_set_timeout(this, timeout);
201  }
202 
203  void
204  getDnInd(co_csdo_ind_t** pind, void** pdata) const noexcept {
205  co_csdo_get_dn_ind(this, pind, pdata);
206  }
207 
208  void
209  setDnInd(co_csdo_ind_t* ind, void* data) noexcept {
210  co_csdo_set_dn_ind(this, ind, data);
211  }
212 
213  template <class F>
214  void
215  setDnInd(F* f) noexcept {
216  setDnInd(&c_obj_call<co_csdo_ind_t*, F>::function, static_cast<void*>(f));
217  }
218 
219  template <class C, typename c_mem_fn<co_csdo_ind_t*, C>::type M>
220  void
221  setDnInd(C* obj) noexcept {
223  static_cast<void*>(obj));
224  }
225 
226  void
227  getUpInd(co_csdo_ind_t** pind, void** pdata) const noexcept {
228  co_csdo_get_up_ind(this, pind, pdata);
229  }
230 
231  void
232  setUpInd(co_csdo_ind_t* ind, void* data) noexcept {
233  co_csdo_set_up_ind(this, ind, data);
234  }
235 
236  template <class F>
237  void
238  setUpInd(F* f) noexcept {
239  setUpInd(&c_obj_call<co_csdo_ind_t*, F>::function, static_cast<void*>(f));
240  }
241 
242  template <class C, typename c_mem_fn<co_csdo_ind_t*, C>::type M>
243  void
244  setUpInd(C* obj) noexcept {
246  static_cast<void*>(obj));
247  }
248 
249  bool
250  isIdle() const noexcept {
251  return !!co_csdo_is_idle(this);
252  }
253 
254  void
255  abortReq(co_unsigned32_t ac = CO_SDO_AC_ERROR) noexcept {
256  co_csdo_abort_req(this, ac);
257  }
258 
259  int
260  dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr, size_t n,
261  co_csdo_dn_con_t* con, void* data) noexcept {
262  return co_csdo_dn_req(this, idx, subidx, ptr, n, con, data);
263  }
264 
265  template <class F>
266  int
267  dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr, size_t n,
268  F* f) noexcept {
269  return dnReq(idx, subidx, ptr, n,
271  static_cast<void*>(f));
272  }
273 
274  template <class T, typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
275  int
276  dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr, size_t n,
277  T* t) noexcept {
278  return dnReq(idx, subidx, ptr, n,
280  static_cast<void*>(t));
281  }
282 
283  template <co_unsigned16_t N>
284  int
285  dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const COVal<N>& val,
286  co_csdo_dn_con_t* con, void* data) noexcept {
287  return co_csdo_dn_val_req(this, idx, subidx, N, &val, con, data);
288  }
289 
290  template <co_unsigned16_t N, class F>
291  int
292  dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const COVal<N>& val,
293  F* f) noexcept {
294  return dnReq<N>(idx, subidx, val,
296  static_cast<void*>(f));
297  }
298 
299  template <co_unsigned16_t N, class T,
301  int
302  dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const COVal<N>& val,
303  T* t) noexcept {
304  return dnReq<N>(idx, subidx, val,
306  static_cast<void*>(t));
307  }
308 
309  int
310  upReq(co_unsigned16_t idx, co_unsigned8_t subidx, co_csdo_up_con_t* con,
311  void* data) noexcept {
312  return co_csdo_up_req(this, idx, subidx, con, data);
313  }
314 
315  template <class T, typename COCSDOUpCon<T>::type M>
316  int
317  upReq(co_unsigned16_t idx, co_unsigned8_t subidx, void* data) noexcept {
318  return upReq(idx, subidx, &COCSDOUpCon<T>::template function<M>, data);
319  }
320 
321  template <class T, class F>
322  int
323  upReq(co_unsigned16_t idx, co_unsigned8_t subidx, F* f) noexcept {
324  return upReq(idx, subidx,
325  &COCSDOUpCon<T>::template function<
326  &c_obj_call<typename COCSDOUpCon<T>::type, F>::function>,
327  static_cast<void*>(f));
328  }
329 
330  template <class T, class C,
331  typename c_mem_fn<typename COCSDOUpCon<T>::type, C>::type M>
332  int
333  upReq(co_unsigned16_t idx, co_unsigned8_t subidx, C* obj) noexcept {
334  return upReq(
335  idx, subidx,
336  &COCSDOUpCon<T>::template function<
337  &c_mem_call<typename COCSDOUpCon<T>::type, C, M>::function>,
338  static_cast<void*>(obj));
339  }
340 
341  int
342  blkDnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
343  size_t n, co_csdo_dn_con_t* con, void* data) noexcept {
344  return co_csdo_blk_dn_req(this, idx, subidx, ptr, n, con, data);
345  }
346 
347  template <class F>
348  int
349  blkDnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
350  size_t n, F* f) noexcept {
351  return blkDnReq(idx, subidx, ptr, n,
353  static_cast<void*>(f));
354  }
355 
356  template <class C, typename c_mem_fn<co_csdo_dn_con_t*, C>::type M>
357  int
358  blkDnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
359  size_t n, C* obj) noexcept {
360  return blkDnReq(idx, subidx, ptr, n,
362  static_cast<void*>(obj));
363  }
364 
365  int
366  blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned8_t pst,
367  co_csdo_up_con_t* con, void* data) noexcept {
368  return co_csdo_blk_up_req(this, idx, subidx, pst, con, data);
369  }
370 
371  template <class T, typename COCSDOUpCon<T>::type M>
372  int
373  blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned8_t pst,
374  void* data) noexcept {
375  return blkUpReq(idx, subidx, pst, &COCSDOUpCon<T>::template function<M>,
376  data);
377  }
378 
379  template <class T, class F>
380  int
381  blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned8_t pst,
382  F* f) noexcept {
383  return blkUpReq(
384  idx, subidx, pst,
385  &COCSDOUpCon<T>::template function<
386  &c_obj_call<typename COCSDOUpCon<T>::type, F>::function>,
387  static_cast<void*>(f));
388  }
389 
390  template <class T, class C,
391  typename c_mem_fn<typename COCSDOUpCon<T>::type, C>::type M>
392  int
393  blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned8_t pst,
394  C* obj) noexcept {
395  return blkUpReq(
396  idx, subidx, pst,
397  &COCSDOUpCon<T>::template function<
398  &c_mem_call<typename COCSDOUpCon<T>::type, C, M>::function>,
399  static_cast<void*>(obj));
400  }
401 
402  protected:
403  ~COCSDO() = default;
404 };
405 
412 template <class T>
413 struct COCSDOUpCon {
414  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
415  co_unsigned32_t ac, T val, void* data);
416 
417  template <type M>
418  static void
419  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
420  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
421  if (!ac) {
422  if (!ptr || n < sizeof(T)) {
424  } else if (n > sizeof(T)) {
426  }
427  }
428  COVal<co_type_traits_T<T>::index> val;
429  if (!ac) ac = co_val_read_sdo(val.index, &val, ptr, n);
430  return (*M)(sdo, idx, subidx, ac, val, data);
431  }
432 };
433 
440 template <>
441 struct COCSDOUpCon<char*> {
442  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
443  co_unsigned32_t ac, const char* vs, void* data);
444 
445  template <type M>
446  static void
447  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
448  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
450  if (!ac && ptr && n) ac = co_val_read_sdo(val.index, &val, ptr, n);
451  return (*M)(sdo, idx, subidx, ac, val, data);
452  }
453 };
454 
461 template <>
462 struct COCSDOUpCon<::std::string> {
463  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
464  co_unsigned32_t ac, ::std::string vs, void* data);
465 
466  template <type M>
467  static void
468  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
469  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
470  const char* vs = static_cast<const char*>(ptr);
471  if (!ac && vs && n) {
472 #if !__cpp_exceptions
473  try {
474 #endif
475  return (*M)(sdo, idx, subidx, ac, ::std::string(vs, vs + n), data);
476 #if !__cpp_exceptions
477  } catch (...) {
478  ac = CO_SDO_AC_NO_MEM;
479  }
480 #endif
481  }
482  return (*M)(sdo, idx, subidx, ac, ::std::string(), data);
483  }
484 };
485 
492 template <>
493 struct COCSDOUpCon<uint_least8_t*> {
494  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
495  co_unsigned32_t ac, const uint_least8_t* os, size_t n,
496  void* data);
497 
498  template <type M>
499  static void
500  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
501  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
502  const uint_least8_t* os = static_cast<const uint_least8_t*>(ptr);
503  return (*M)(sdo, idx, subidx, ac, n ? os : 0, n, data);
504  }
505 };
506 
513 template <>
514 struct COCSDOUpCon<::std::vector<uint_least8_t>> {
515  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
516  co_unsigned32_t ac, ::std::vector<uint_least8_t> os,
517  void* data);
518 
519  template <type M>
520  static void
521  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
522  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
523  const uint_least8_t* os = static_cast<const uint_least8_t*>(ptr);
524  if (!ac && os && n) {
525 #if !__cpp_exceptions
526  try {
527 #endif
528  return (*M)(sdo, idx, subidx, ac,
529  ::std::vector<uint_least8_t>(os, os + n), data);
530 #if !__cpp_exceptions
531  } catch (...) {
532  ac = CO_SDO_AC_NO_MEM;
533  }
534 #endif
535  }
536  return (*M)(sdo, idx, subidx, ac, ::std::vector<uint_least8_t>(), data);
537  }
538 };
539 
546 template <>
547 struct COCSDOUpCon<char16_t*> {
548  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
549  co_unsigned32_t ac, const char16_t* us, void* data);
550 
551  template <type M>
552  static void
553  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
554  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
556  if (!ac && ptr && n) ac = co_val_read_sdo(val.index, &val, ptr, n);
557  return (*M)(sdo, idx, subidx, ac, val, data);
558  }
559 };
560 
567 template <>
568 struct COCSDOUpCon<::std::basic_string<char16_t>> {
569  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
570  co_unsigned32_t ac, ::std::basic_string<char16_t> us,
571  void* data);
572 
573  template <type M>
574  static void
575  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
576  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
578  if (!ac && ptr && n) ac = co_val_read_sdo(val.index, &val, ptr, n);
579  const char16_t* us = val;
580  if (!ac && us && n) {
581 #if !__cpp_exceptions
582  try {
583 #endif
584  return (*M)(sdo, idx, subidx, ac,
585  ::std::basic_string<char16_t>(us, us + n), data);
586 #if !__cpp_exceptions
587  } catch (...) {
588  ac = CO_SDO_AC_NO_MEM;
589  }
590 #endif
591  }
592  return (*M)(sdo, idx, subidx, ac, ::std::basic_string<char16_t>(), data);
593  }
594 };
595 
602 template <>
603 struct COCSDOUpCon<void*> {
604  typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
605  co_unsigned32_t ac, const void* dom, size_t n,
606  void* data);
607 
608  template <type M>
609  static void
610  function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
611  co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
612  return (*M)(sdo, idx, subidx, ac, n ? ptr : 0, n, data);
613  }
614 };
615 
616 } // namespace lely
617 
618 #endif // !LELY_CO_CSDO_HPP_
co_csdo_blk_up_req
int co_csdo_blk_up_req(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned8_t pst, co_csdo_up_con_t *con, void *data)
Submits a block upload request to a remote Server-SDO.
Definition: csdo.c:1356
lely::incomplete_c_type
The base class for a C++ interface to an incomplete C type.
Definition: c_type.hpp:249
co_csdo_abort_req
void co_csdo_abort_req(co_csdo_t *sdo, co_unsigned32_t ac)
Submits an abort transfer request to a remote Server-SDO.
Definition: csdo.c:1211
lely::COCSDO
An opaque CANopen Client-SDO service type.
Definition: csdo.hpp:157
co_csdo_start
int co_csdo_start(co_csdo_t *sdo)
Starts a Client-SDO service.
Definition: csdo.c:1034
lely::c_mem_fn
Definition: c_call.hpp:65
co_dev_dn_req
int co_dev_dn_req(co_dev_t *dev, co_unsigned16_t idx, co_unsigned8_t subidx, const void *ptr, size_t n, co_csdo_dn_con_t *con, void *data)
Submits a download request to a local device.
Definition: csdo.c:664
net.hpp
co_csdo_ind_t
void co_csdo_ind_t(const co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, size_t size, size_t nbyte, void *data)
The type of a CANopen Client-SDO request progress indication function, used to notify the user of the...
Definition: csdo.h:79
CO_SDO_AC_TYPE_LEN_LO
#define CO_SDO_AC_TYPE_LEN_LO
SDO abort code: Data type does not match, length of service parameter too low.
Definition: sdo.h:129
CO_SDO_AC_NO_MEM
#define CO_SDO_AC_NO_MEM
SDO abort code: Out of memory.
Definition: sdo.h:81
co_csdo_get_par
const struct co_sdo_par * co_csdo_get_par(const co_csdo_t *sdo)
Returns a pointer to the SDO parameter record of a Client-SDO.
Definition: csdo.c:1126
lely::c_obj_call
Definition: c_call.hpp:62
val.hpp
co_val_read_sdo
co_unsigned32_t co_val_read_sdo(co_unsigned16_t type, void *val, const void *ptr, size_t n)
Reads a value of the specified data type from an SDO buffer.
Definition: val.c:767
CO_SDO_AC_TYPE_LEN_HI
#define CO_SDO_AC_TYPE_LEN_HI
SDO abort code: Data type does not match, length of service parameter too high.
Definition: sdo.h:123
co_dev_up_req
int co_dev_up_req(const co_dev_t *dev, co_unsigned16_t idx, co_unsigned8_t subidx, co_csdo_up_con_t *con, void *data)
Submits an upload request to a local device.
Definition: csdo.c:812
co_csdo_is_idle
int co_csdo_is_idle(const co_csdo_t *sdo)
Returns 1 if the specified Client-SDO service is idle, and 0 if a transfer is ongoing.
Definition: csdo.c:1203
co_csdo_get_timeout
int co_csdo_get_timeout(const co_csdo_t *sdo)
Returns the timeout (in milliseconds) of a Client-SDO.
Definition: csdo.c:1134
lely::COVal< CO_DEFTYPE_VISIBLE_STRING >
A CANopen value containing an array of visible characters.
Definition: val.hpp:96
lely::COVal< CO_DEFTYPE_UNICODE_STRING >
A CANopen value containing an array of (16-bit) Unicode characters.
Definition: val.hpp:258
co_csdo_get_net
can_net_t * co_csdo_get_net(const co_csdo_t *sdo)
Returns a pointer to the CAN network of a Client-SDO.
Definition: csdo.c:1102
lely::CANNet
An opaque CAN network interface type.
Definition: net.hpp:85
lely::c_type_traits
A class template supplying a uniform interface to certain attributes of C types.
Definition: c_type.hpp:120
CO_SDO_AC_ERROR
#define CO_SDO_AC_ERROR
SDO abort code: General error.
Definition: sdo.h:150
co_csdo_up_con_t
void co_csdo_up_con_t(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned32_t ac, const void *ptr, size_t n, void *data)
The type of a CANopen Client-SDO upload confirmation callback function, invoked when an upload reques...
Definition: csdo.h:59
lely::COVal
A CANopen value.
Definition: val.hpp:42
lely::c_mem_call
Definition: c_call.hpp:67
co_csdo_blk_dn_req
int co_csdo_blk_dn_req(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, const void *ptr, size_t n, co_csdo_dn_con_t *con, void *data)
Submits a block download request to a remote Server-SDO.
Definition: csdo.c:1313
co_csdo_up_req
int co_csdo_up_req(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, co_csdo_up_con_t *con, void *data)
Submits an upload request to a remote Server-SDO.
Definition: csdo.c:1294
co_csdo_set_timeout
void co_csdo_set_timeout(co_csdo_t *sdo, int timeout)
Sets the timeout of a Client-SDO.
Definition: csdo.c:1142
co_csdo_stop
void co_csdo_stop(co_csdo_t *sdo)
Stops a Client-SDO service.
Definition: csdo.c:1069
__co_csdo
A CANopen Client-SDO.
Definition: csdo.c:71
co_csdo_dn_con_t
void co_csdo_dn_con_t(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned32_t ac, void *data)
The type of a CANopen Client-SDO download confirmation callback function, invoked when a download req...
Definition: csdo.h:43
lely::COCSDOUpCon
A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received value on suc...
Definition: csdo.hpp:40
co_csdo_get_dn_ind
void co_csdo_get_dn_ind(const co_csdo_t *sdo, co_csdo_ind_t **pind, void **pdata)
Retrieves the indication function used to notify the user of the progress of the current SDO download...
Definition: csdo.c:1153
csdo.h
co_csdo_set_up_ind
void co_csdo_set_up_ind(co_csdo_t *sdo, co_csdo_ind_t *ind, void *data)
Sets the indication function used to notify the user of the progress of the current SDO upload reques...
Definition: csdo.c:1184
co_csdo_dn_req
int co_csdo_dn_req(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, const void *ptr, size_t n, co_csdo_dn_con_t *con, void *data)
Submits a download request to a remote Server-SDO.
Definition: csdo.c:1219
co_csdo_get_dev
co_dev_t * co_csdo_get_dev(const co_csdo_t *sdo)
Returns a pointer to the CANopen device of a Client-SDO.
Definition: csdo.c:1110
co_csdo_set_dn_ind
void co_csdo_set_dn_ind(co_csdo_t *sdo, co_csdo_ind_t *ind, void *data)
Sets the indication function used to notify the user of the progress of the current SDO download requ...
Definition: csdo.c:1164
co_csdo_get_up_ind
void co_csdo_get_up_ind(const co_csdo_t *sdo, co_csdo_ind_t **pind, void **pdata)
Retrieves the indication function used to notify the user of the progress of the current SDO upload r...
Definition: csdo.c:1173
co_sdo_par
An SDO parameter record.
Definition: sdo.h:45
co_dev_dn_val_req
int co_dev_dn_val_req(co_dev_t *dev, co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned16_t type, const void *val, co_csdo_dn_con_t *con, void *data)
Submits a download request to a local device.
Definition: csdo.c:701
co_csdo_dn_val_req
int co_csdo_dn_val_req(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, co_unsigned16_t type, const void *val, co_csdo_dn_con_t *con, void *data)
Submits a download request to a remote Server-SDO.
Definition: csdo.c:1241
co_csdo_get_num
co_unsigned8_t co_csdo_get_num(const co_csdo_t *sdo)
Returns the SDO number of a Client-SDO.
Definition: csdo.c:1118
lely::CODev
An opaque CANopen device type.
Definition: dev.hpp:77