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_