obj.h

Go to the documentation of this file.

 
#ifndef LELY_CO_OBJ_H_
#define LELY_CO_OBJ_H_
 
#include <lely/co/type.h>
 
#include <stddef.h>
 
#define CO_OBJECT_NULL 0x00
 
#define CO_OBJECT_DOMAIN 0x02
 
#define CO_OBJECT_DEFTYPE 0x05
 
#define CO_OBJECT_DEFSTRUCT 0x06
 
#define CO_OBJECT_VAR 0x07
 
#define CO_OBJECT_ARRAY 0x08
 
#define CO_OBJECT_RECORD 0x09
 
#define CO_ACCESS_READ 0x01
 
#define CO_ACCESS_WRITE 0x02
 
#define CO_ACCESS_TPDO 0x04
 
#define CO_ACCESS_RPDO 0x08
 
#define CO_ACCESS_RO (CO_ACCESS_READ | CO_ACCESS_TPDO)
 
#define CO_ACCESS_WO (CO_ACCESS_WRITE | CO_ACCESS_RPDO)
 
#define CO_ACCESS_RW (CO_ACCESS_RO | CO_ACCESS_WO)
 
#define CO_ACCESS_RWR (CO_ACCESS_RO | CO_ACCESS_WRITE)
 
#define CO_ACCESS_RWW (CO_ACCESS_WO | CO_ACCESS_READ)
 
#define CO_ACCESS_CONST (CO_ACCESS_RO | 0x10)
 
#define CO_OBJ_FLAGS_READ 0x01
 
#define CO_OBJ_FLAGS_WRITE 0x02
 
#define CO_OBJ_FLAGS_UPLOAD_FILE 0x04
 
#define CO_OBJ_FLAGS_DOWNLOAD_FILE 0x08
 
#define CO_OBJ_FLAGS_MIN_NODEID 0x10
 
#define CO_OBJ_FLAGS_MAX_NODEID 0x20
 
#define CO_OBJ_FLAGS_DEF_NODEID 0x40
 
#define CO_OBJ_FLAGS_VAL_NODEID 0x80
 
struct co_sdo_req;
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef co_unsigned32_t co_sub_dn_ind_t(
                co_sub_t *sub, struct co_sdo_req *req, void *data);
 
typedef co_unsigned32_t co_sub_up_ind_t(
                const co_sub_t *sub, struct co_sdo_req *req, void *data);
 
void *__co_obj_alloc(void);
void __co_obj_free(void *ptr);
struct __co_obj *__co_obj_init(struct __co_obj *obj, co_unsigned16_t idx);
void __co_obj_fini(struct __co_obj *obj);
 
co_obj_t *co_obj_create(co_unsigned16_t idx);
 
void co_obj_destroy(co_obj_t *obj);
 
co_dev_t *co_obj_get_dev(const co_obj_t *obj);
 
co_unsigned16_t co_obj_get_idx(const co_obj_t *obj);
 
co_unsigned8_t co_obj_get_subidx(const co_obj_t *obj, co_unsigned8_t maxsubidx,
                co_unsigned8_t *subidx);
 
int co_obj_insert_sub(co_obj_t *obj, co_sub_t *sub);
 
int co_obj_remove_sub(co_obj_t *obj, co_sub_t *sub);
 
co_sub_t *co_obj_find_sub(const co_obj_t *obj, co_unsigned8_t subidx);
 
const char *co_obj_get_name(const co_obj_t *obj);
 
int co_obj_set_name(co_obj_t *obj, const char *name);
 
co_unsigned8_t co_obj_get_code(const co_obj_t *obj);
 
int co_obj_set_code(co_obj_t *obj, co_unsigned8_t code);
 
void *co_obj_addressof_val(const co_obj_t *obj);
 
size_t co_obj_sizeof_val(const co_obj_t *obj);
 
const void *co_obj_get_val(const co_obj_t *obj, co_unsigned8_t subidx);
 
size_t co_obj_set_val(co_obj_t *obj, co_unsigned8_t subidx, const void *ptr,
                size_t n);
 
#define LELY_CO_DEFINE_TYPE(a, b, c, d) \
        co_##b##_t co_obj_get_val_##c( \
                        const co_obj_t *obj, co_unsigned8_t subidx); \
        size_t co_obj_set_val_##c( \
                        co_obj_t *obj, co_unsigned8_t subidx, co_##b##_t c);
#include <lely/co/def/basic.def>
#undef LELY_CO_DEFINE_TYPE
 
void co_obj_set_dn_ind(co_obj_t *obj, co_sub_dn_ind_t *ind, void *data);
 
void co_obj_set_up_ind(co_obj_t *obj, co_sub_up_ind_t *ind, void *data);
 
void *__co_sub_alloc(void);
void __co_sub_free(void *ptr);
struct __co_sub *__co_sub_init(struct __co_sub *sub, co_unsigned8_t subidx,
                co_unsigned16_t type);
void __co_sub_fini(struct __co_sub *sub);
 
co_sub_t *co_sub_create(co_unsigned8_t subidx, co_unsigned16_t type);
 
void co_sub_destroy(co_sub_t *sub);
 
co_obj_t *co_sub_get_obj(const co_sub_t *sub);
 
co_unsigned8_t co_sub_get_subidx(const co_sub_t *sub);
 
const char *co_sub_get_name(const co_sub_t *sub);
 
int co_sub_set_name(co_sub_t *sub, const char *name);
 
co_unsigned16_t co_sub_get_type(const co_sub_t *sub);
 
const void *co_sub_addressof_min(const co_sub_t *sub);
 
size_t co_sub_sizeof_min(const co_sub_t *sub);
 
const void *co_sub_get_min(const co_sub_t *sub);
 
size_t co_sub_set_min(co_sub_t *sub, const void *ptr, size_t n);
 
const void *co_sub_addressof_max(const co_sub_t *sub);
 
size_t co_sub_sizeof_max(const co_sub_t *sub);
 
const void *co_sub_get_max(const co_sub_t *sub);
 
size_t co_sub_set_max(co_sub_t *sub, const void *ptr, size_t n);
 
const void *co_sub_addressof_def(const co_sub_t *sub);
 
size_t co_sub_sizeof_def(const co_sub_t *sub);
 
const void *co_sub_get_def(const co_sub_t *sub);
 
size_t co_sub_set_def(co_sub_t *sub, const void *ptr, size_t n);
 
const void *co_sub_addressof_val(const co_sub_t *sub);
 
size_t co_sub_sizeof_val(const co_sub_t *sub);
 
const void *co_sub_get_val(const co_sub_t *sub);
 
size_t co_sub_set_val(co_sub_t *sub, const void *ptr, size_t n);
 
#define LELY_CO_DEFINE_TYPE(a, b, c, d) \
        co_##b##_t co_sub_get_val_##c(const co_sub_t *sub); \
        size_t co_sub_set_val_##c(co_sub_t *sub, co_##b##_t c);
#include <lely/co/def/basic.def>
#undef LELY_CO_DEFINE_TYPE
 
co_unsigned32_t co_sub_chk_val(
                const co_sub_t *sub, co_unsigned16_t type, const void *val);
 
unsigned int co_sub_get_access(const co_sub_t *sub);
 
int co_sub_set_access(co_sub_t *sub, unsigned int access);
 
int co_sub_get_pdo_mapping(const co_sub_t *sub);
 
void co_sub_set_pdo_mapping(co_sub_t *sub, int pdo_mapping);
 
unsigned int co_sub_get_flags(const co_sub_t *sub);
 
void co_sub_set_flags(co_sub_t *sub, unsigned int flags);
 
void co_sub_get_dn_ind(
                const co_sub_t *sub, co_sub_dn_ind_t **pind, void **pdata);
 
void co_sub_set_dn_ind(co_sub_t *sub, co_sub_dn_ind_t *ind, void *data);
 
co_unsigned32_t co_sub_on_dn(co_sub_t *sub, struct co_sdo_req *req);
 
co_unsigned32_t co_sub_dn_ind(co_sub_t *sub, struct co_sdo_req *req);
 
co_unsigned32_t co_sub_dn_ind_val(
                co_sub_t *sub, co_unsigned16_t type, const void *val);
 
int co_sub_dn(co_sub_t *sub, void *val);
 
void co_sub_get_up_ind(
                const co_sub_t *sub, co_sub_up_ind_t **pind, void **pdata);
 
void co_sub_set_up_ind(co_sub_t *sub, co_sub_up_ind_t *ind, void *data);
 
co_unsigned32_t co_sub_on_up(const co_sub_t *sub, struct co_sdo_req *req);
 
co_unsigned32_t co_sub_up_ind(const co_sub_t *sub, struct co_sdo_req *req);
 
#ifdef __cplusplus
}
#endif
 
#endif // !LELY_CO_OBJ_H_