Lely core libraries 1.9.2
csdo.hpp
Go to the documentation of this file.
1
23#ifndef LELY_CO_CSDO_HPP_
24#define LELY_CO_CSDO_HPP_
25
26#ifndef __cplusplus
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
37namespace lely {
38
39template <class>
40struct COCSDOUpCon;
41
42inline int
43dnReq(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
48template <class F>
49inline int
50dnReq(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,
53 &c_obj_call<co_csdo_dn_con_t*, F>::function,
54 static_cast<void*>(f));
55}
56
57template <class T, typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
58inline int
59dnReq(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
66template <co_unsigned16_t N>
67inline int
68dnReq(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
73template <co_unsigned16_t N, class F>
74inline int
75dnReq(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
82template <co_unsigned16_t N, class T,
83 typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
84inline int
85dnReq(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
92inline int
93upReq(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
98template <class T, typename COCSDOUpCon<T>::type M>
99inline int
100upReq(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
105template <class T, class F>
106inline int
107upReq(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
115template <class T, class C,
116 typename c_mem_fn<typename COCSDOUpCon<T>::type, C>::type M>
117inline int
118upReq(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
127template <>
128struct c_type_traits<__co_csdo> {
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 static void
140 free(void* ptr) noexcept {
141 __co_csdo_free(ptr);
142 }
143
144 static pointer
145 init(pointer p, CANNet* net, CODev* dev, co_unsigned8_t num) noexcept {
146 return __co_csdo_init(p, net, dev, num);
147 }
148
149 static void
150 fini(pointer p) noexcept {
151 __co_csdo_fini(p);
152 }
153};
154
156class COCSDO : public incomplete_c_type<__co_csdo> {
157 typedef incomplete_c_type<__co_csdo> c_base;
158
159 public:
160 COCSDO(CANNet* net, CODev* dev, co_unsigned8_t num) : c_base(net, dev, num) {}
161
162 CANNet*
163 getNet() const noexcept {
164 return co_csdo_get_net(this);
165 }
166 CODev*
167 getDev() const noexcept {
168 return co_csdo_get_dev(this);
169 }
170 co_unsigned8_t
171 getNum() const noexcept {
172 return co_csdo_get_num(this);
173 }
174
175 const co_sdo_par&
176 getPar() const noexcept {
177 return *co_csdo_get_par(this);
178 }
179
180 int
181 getTimeout() const noexcept {
182 return co_csdo_get_timeout(this);
183 }
184
185 void
186 setTimeout(int timeout) noexcept {
187 co_csdo_set_timeout(this, timeout);
188 }
189
190 void
191 getDnInd(co_csdo_ind_t** pind, void** pdata) const noexcept {
192 co_csdo_get_dn_ind(this, pind, pdata);
193 }
194
195 void
196 setDnInd(co_csdo_ind_t* ind, void* data) noexcept {
197 co_csdo_set_dn_ind(this, ind, data);
198 }
199
200 template <class F>
201 void
202 setDnInd(F* f) noexcept {
203 setDnInd(&c_obj_call<co_csdo_ind_t*, F>::function, static_cast<void*>(f));
204 }
205
206 template <class C, typename c_mem_fn<co_csdo_ind_t*, C>::type M>
207 void
208 setDnInd(C* obj) noexcept {
209 setDnInd(&c_mem_call<co_csdo_ind_t*, C, M>::function,
210 static_cast<void*>(obj));
211 }
212
213 void
214 getUpInd(co_csdo_ind_t** pind, void** pdata) const noexcept {
215 co_csdo_get_up_ind(this, pind, pdata);
216 }
217
218 void
219 setUpInd(co_csdo_ind_t* ind, void* data) noexcept {
220 co_csdo_set_up_ind(this, ind, data);
221 }
222
223 template <class F>
224 void
225 setUpInd(F* f) noexcept {
226 setUpInd(&c_obj_call<co_csdo_ind_t*, F>::function, static_cast<void*>(f));
227 }
228
229 template <class C, typename c_mem_fn<co_csdo_ind_t*, C>::type M>
230 void
231 setUpInd(C* obj) noexcept {
232 setUpInd(&c_mem_call<co_csdo_ind_t*, C, M>::function,
233 static_cast<void*>(obj));
234 }
235
236 bool
237 isIdle() const noexcept {
238 return !!co_csdo_is_idle(this);
239 }
240
241 void
242 abortReq(co_unsigned32_t ac = CO_SDO_AC_ERROR) noexcept {
243 co_csdo_abort_req(this, ac);
244 }
245
246 int
247 dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr, size_t n,
248 co_csdo_dn_con_t* con, void* data) noexcept {
249 return co_csdo_dn_req(this, idx, subidx, ptr, n, con, data);
250 }
251
252 template <class F>
253 int
254 dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr, size_t n,
255 F* f) noexcept {
256 return dnReq(idx, subidx, ptr, n,
257 &c_obj_call<co_csdo_dn_con_t*, F>::function,
258 static_cast<void*>(f));
259 }
260
261 template <class T, typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
262 int
263 dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr, size_t n,
264 T* t) noexcept {
265 return dnReq(idx, subidx, ptr, n,
266 &c_mem_call<co_csdo_dn_con_t*, T, M>::function,
267 static_cast<void*>(t));
268 }
269
270 template <co_unsigned16_t N>
271 int
272 dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const COVal<N>& val,
273 co_csdo_dn_con_t* con, void* data) noexcept {
274 return co_csdo_dn_val_req(this, idx, subidx, N, &val, con, data);
275 }
276
277 template <co_unsigned16_t N, class F>
278 int
279 dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const COVal<N>& val,
280 F* f) noexcept {
281 return dnReq<N>(idx, subidx, val,
282 &c_obj_call<co_csdo_dn_con_t*, F>::function,
283 static_cast<void*>(f));
284 }
285
286 template <co_unsigned16_t N, class T,
287 typename c_mem_fn<co_csdo_dn_con_t*, T>::type M>
288 int
289 dnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const COVal<N>& val,
290 T* t) noexcept {
291 return dnReq<N>(idx, subidx, val,
292 &c_mem_call<co_csdo_dn_con_t*, T, M>::function,
293 static_cast<void*>(t));
294 }
295
296 int
297 upReq(co_unsigned16_t idx, co_unsigned8_t subidx, co_csdo_up_con_t* con,
298 void* data) noexcept {
299 return co_csdo_up_req(this, idx, subidx, con, data);
300 }
301
302 template <class T, typename COCSDOUpCon<T>::type M>
303 int
304 upReq(co_unsigned16_t idx, co_unsigned8_t subidx, void* data) noexcept {
305 return upReq(idx, subidx, &COCSDOUpCon<T>::template function<M>, data);
306 }
307
308 template <class T, class F>
309 int
310 upReq(co_unsigned16_t idx, co_unsigned8_t subidx, F* f) noexcept {
311 return upReq(idx, subidx,
312 &COCSDOUpCon<T>::template function<
313 &c_obj_call<typename COCSDOUpCon<T>::type, F>::function>,
314 static_cast<void*>(f));
315 }
316
317 template <class T, class C,
318 typename c_mem_fn<typename COCSDOUpCon<T>::type, C>::type M>
319 int
320 upReq(co_unsigned16_t idx, co_unsigned8_t subidx, C* obj) noexcept {
321 return upReq(
322 idx, subidx,
323 &COCSDOUpCon<T>::template function<
324 &c_mem_call<typename COCSDOUpCon<T>::type, C, M>::function>,
325 static_cast<void*>(obj));
326 }
327
328 int
329 blkDnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
330 size_t n, co_csdo_dn_con_t* con, void* data) noexcept {
331 return co_csdo_blk_dn_req(this, idx, subidx, ptr, n, con, data);
332 }
333
334 template <class F>
335 int
336 blkDnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
337 size_t n, F* f) noexcept {
338 return blkDnReq(idx, subidx, ptr, n,
339 &c_obj_call<co_csdo_dn_con_t*, F>::function,
340 static_cast<void*>(f));
341 }
342
343 template <class C, typename c_mem_fn<co_csdo_dn_con_t*, C>::type M>
344 int
345 blkDnReq(co_unsigned16_t idx, co_unsigned8_t subidx, const void* ptr,
346 size_t n, C* obj) noexcept {
347 return blkDnReq(idx, subidx, ptr, n,
348 &c_mem_call<co_csdo_dn_con_t*, C, M>::function,
349 static_cast<void*>(obj));
350 }
351
352 int
353 blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, uint8_t pst,
354 co_csdo_up_con_t* con, void* data) noexcept {
355 return co_csdo_blk_up_req(this, idx, subidx, pst, con, data);
356 }
357
358 template <class T, typename COCSDOUpCon<T>::type M>
359 int
360 blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, uint8_t pst,
361 void* data) noexcept {
362 return blkUpReq(idx, subidx, pst, &COCSDOUpCon<T>::template function<M>,
363 data);
364 }
365
366 template <class T, class F>
367 int
368 blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, uint8_t pst,
369 F* f) noexcept {
370 return blkUpReq(
371 idx, subidx, pst,
372 &COCSDOUpCon<T>::template function<
373 &c_obj_call<typename COCSDOUpCon<T>::type, F>::function>,
374 static_cast<void*>(f));
375 }
376
377 template <class T, class C,
378 typename c_mem_fn<typename COCSDOUpCon<T>::type, C>::type M>
379 int
380 blkUpReq(co_unsigned16_t idx, co_unsigned8_t subidx, uint8_t pst,
381 C* obj) noexcept {
382 return blkUpReq(
383 idx, subidx, pst,
384 &COCSDOUpCon<T>::template function<
385 &c_mem_call<typename COCSDOUpCon<T>::type, C, M>::function>,
386 static_cast<void*>(obj));
387 }
388
389 protected:
390 ~COCSDO() {}
391};
392
399template <class T>
400struct COCSDOUpCon {
401 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
402 co_unsigned32_t ac, T val, void* data);
403
404 template <type M>
405 static void
406 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
407 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
408 if (!ac) {
409 if (!ptr || n < sizeof(T)) {
410 ac = CO_SDO_AC_TYPE_LEN_LO;
411 } else if (n > sizeof(T)) {
412 ac = CO_SDO_AC_TYPE_LEN_HI;
413 }
414 }
415 COVal<co_type_traits_T<T>::index> val;
416 if (!ac) ac = co_val_read_sdo(val.index, &val, ptr, n);
417 return (*M)(sdo, idx, subidx, ac, val, data);
418 }
419};
420
427template <>
428struct COCSDOUpCon<char*> {
429 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
430 co_unsigned32_t ac, const char* vs, void* data);
431
432 template <type M>
433 static void
434 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
435 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
436 COVal<CO_DEFTYPE_VISIBLE_STRING> val;
437 if (!ac && ptr && n) ac = co_val_read_sdo(val.index, &val, ptr, n);
438 return (*M)(sdo, idx, subidx, ac, val, data);
439 }
440};
441
448template <>
449struct COCSDOUpCon<::std::string> {
450 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
451 co_unsigned32_t ac, ::std::string vs, void* data);
452
453 template <type M>
454 static void
455 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
456 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
457 const char* vs = static_cast<const char*>(ptr);
458 if (!ac && vs && n) {
459#if !__cpp_exceptions
460 try {
461#endif
462 return (*M)(sdo, idx, subidx, ac, ::std::string(vs, vs + n), data);
463#if !__cpp_exceptions
464 } catch (...) {
465 ac = CO_SDO_AC_NO_MEM;
466 }
467#endif
468 }
469 return (*M)(sdo, idx, subidx, ac, ::std::string(), data);
470 }
471};
472
479template <>
480struct COCSDOUpCon<uint8_t*> {
481 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
482 co_unsigned32_t ac, const uint8_t* os, size_t n,
483 void* data);
484
485 template <type M>
486 static void
487 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
488 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
489 const uint8_t* os = static_cast<const uint8_t*>(ptr);
490 return (*M)(sdo, idx, subidx, ac, n ? os : 0, n, data);
491 }
492};
493
500template <>
501struct COCSDOUpCon<::std::vector<uint8_t>> {
502 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
503 co_unsigned32_t ac, ::std::vector<uint8_t> os,
504 void* data);
505
506 template <type M>
507 static void
508 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
509 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
510 const uint8_t* os = static_cast<const uint8_t*>(ptr);
511 if (!ac && os && n) {
512#if !__cpp_exceptions
513 try {
514#endif
515 return (*M)(sdo, idx, subidx, ac, ::std::vector<uint8_t>(os, os + n),
516 data);
517#if !__cpp_exceptions
518 } catch (...) {
519 ac = CO_SDO_AC_NO_MEM;
520 }
521#endif
522 }
523 return (*M)(sdo, idx, subidx, ac, ::std::vector<uint8_t>(), data);
524 }
525};
526
533template <>
534struct COCSDOUpCon<char16_t*> {
535 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
536 co_unsigned32_t ac, const char16_t* us, void* data);
537
538 template <type M>
539 static void
540 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
541 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
542 COVal<CO_DEFTYPE_UNICODE_STRING> val;
543 if (!ac && ptr && n) ac = co_val_read_sdo(val.index, &val, ptr, n);
544 return (*M)(sdo, idx, subidx, ac, val, data);
545 }
546};
547
554template <>
555struct COCSDOUpCon<::std::basic_string<char16_t>> {
556 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
557 co_unsigned32_t ac, ::std::basic_string<char16_t> us,
558 void* data);
559
560 template <type M>
561 static void
562 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
563 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
564 COVal<CO_DEFTYPE_UNICODE_STRING> val;
565 if (!ac && ptr && n) ac = co_val_read_sdo(val.index, &val, ptr, n);
566 const char16_t* us = val;
567 if (!ac && us && n) {
568#if !__cpp_exceptions
569 try {
570#endif
571 return (*M)(sdo, idx, subidx, ac,
572 ::std::basic_string<char16_t>(us, us + n), data);
573#if !__cpp_exceptions
574 } catch (...) {
575 ac = CO_SDO_AC_NO_MEM;
576 }
577#endif
578 }
579 return (*M)(sdo, idx, subidx, ac, ::std::basic_string<char16_t>(), data);
580 }
581};
582
589template <>
590struct COCSDOUpCon<void*> {
591 typedef void (*type)(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
592 co_unsigned32_t ac, const void* dom, size_t n,
593 void* data);
594
595 template <type M>
596 static void
597 function(COCSDO* sdo, co_unsigned16_t idx, co_unsigned8_t subidx,
598 co_unsigned32_t ac, const void* ptr, size_t n, void* data) noexcept {
599 return (*M)(sdo, idx, subidx, ac, n ? ptr : 0, n, data);
600 }
601};
602
603} // namespace lely
604
605#endif // !LELY_CO_CSDO_HPP_
lely::CANNet
An opaque CAN network interface type.
Definition: net.hpp:83
lely::COCSDO
An opaque CANopen Client-SDO service type.
Definition: csdo.hpp:156
lely::CODev
An opaque CANopen device type.
Definition: dev.hpp:76
lely::COVal
A CANopen value.
Definition: val.hpp:42
lely::incomplete_c_type
The base class for a C++ interface to an incomplete C type.
Definition: c_type.hpp:245
csdo.h
This header file is part of the CANopen library; it contains the Client-SDO declarations.
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:1080
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
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:675
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:995
co_csdo_blk_up_req
int co_csdo_blk_up_req(co_csdo_t *sdo, co_unsigned16_t idx, co_unsigned8_t subidx, uint8_t pst, co_csdo_up_con_t *con, void *data)
Submits a block upload request to a remote Server-SDO.
Definition: csdo.c:1121
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:1011
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:637
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
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:600
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:904
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:912
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:944
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:936
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:1099
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:986
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:1003
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_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:975
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:928
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:966
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:920
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:955
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:1036
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_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_SDO_AC_ERROR
#define CO_SDO_AC_ERROR
SDO abort code: General error.
Definition: sdo.h:150
CO_SDO_AC_NO_MEM
#define CO_SDO_AC_NO_MEM
SDO abort code: Out of memory.
Definition: sdo.h:81
lely
Global namespace for the Lely Industries N.V. libraries.
Definition: buf.hpp:32
net.hpp
This header file is part of the CAN library; it contains the C++ interface of the CAN network interfa...
__co_csdo
A CANopen Client-SDO.
Definition: csdo.c:45
co_sdo_par
An SDO parameter record.
Definition: sdo.h:45
lely::COCSDOUpCon
A CANopen Client-SDO upload confirmation callback wrapper that deserializes the received value on suc...
Definition: csdo.hpp:400
lely::c_mem_call
Definition: c_call.hpp:67
lely::c_mem_fn
Definition: c_call.hpp:65
lely::c_obj_call
Definition: c_call.hpp:62
lely::c_type_traits
A class template supplying a uniform interface to certain attributes of C types.
Definition: c_type.hpp:344
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:698
val.hpp
This header file is part of the CANopen library; it contains the C++ interface of the CANopen value d...