net.h

Go to the documentation of this file.

 
#ifndef LELY_CAN_NET_H_
#define LELY_CAN_NET_H_
 
#include <lely/can/msg.h>
#include <lely/libc/time.h>
 
struct __can_net;
#if !defined(__cplusplus) || LELY_NO_CXX
typedef struct __can_net can_net_t;
#endif
 
struct __can_timer;
#if !defined(__cplusplus) || LELY_NO_CXX
typedef struct __can_timer can_timer_t;
#endif
 
struct __can_recv;
#if !defined(__cplusplus) || LELY_NO_CXX
typedef struct __can_recv can_recv_t;
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

typedef int can_timer_func_t(const struct timespec *tp, void *data);

typedef int can_recv_func_t(const struct can_msg *msg, void *data);

typedef int can_send_func_t(const struct can_msg *msg, void *data);
 
void *__can_net_alloc(void);
void __can_net_free(void *ptr);
struct __can_net *__can_net_init(struct __can_net *net);
void __can_net_fini(struct __can_net *net);

can_net_t *can_net_create(void);

void can_net_destroy(can_net_t *net);

void can_net_get_time(const can_net_t *net, struct timespec *tp);

int can_net_set_time(can_net_t *net, const struct timespec *tp);

void can_net_get_next_func(
                const can_net_t *net, can_timer_func_t **pfunc, void **pdata);

void can_net_set_next_func(can_net_t *net, can_timer_func_t *func, void *data);

int can_net_recv(can_net_t *net, const struct can_msg *msg);

int can_net_send(can_net_t *net, const struct can_msg *msg);

void can_net_get_send_func(
                const can_net_t *net, can_send_func_t **pfunc, void **pdata);

void can_net_set_send_func(can_net_t *net, can_send_func_t *func, void *data);
 
void *__can_timer_alloc(void);
void __can_timer_free(void *ptr);
struct __can_timer *__can_timer_init(struct __can_timer *timer);
void __can_timer_fini(struct __can_timer *timer);

can_timer_t *can_timer_create(void);

void can_timer_destroy(can_timer_t *timer);

void can_timer_get_func(const can_timer_t *timer, can_timer_func_t **pfunc,
                void **pdata);

void can_timer_set_func(can_timer_t *timer, can_timer_func_t *func, void *data);

void can_timer_start(can_timer_t *timer, can_net_t *net,
                const struct timespec *start, const struct timespec *interval);

void can_timer_stop(can_timer_t *timer);

void can_timer_timeout(can_timer_t *timer, can_net_t *net, int timeout);
 
void *__can_recv_alloc(void);
void __can_recv_free(void *ptr);
struct __can_recv *__can_recv_init(struct __can_recv *recv);
void __can_recv_fini(struct __can_recv *recv);

can_recv_t *can_recv_create(void);

void can_recv_destroy(can_recv_t *recv);

void can_recv_get_func(
                const can_recv_t *recv, can_recv_func_t **pfunc, void **pdata);

void can_recv_set_func(can_recv_t *recv, can_recv_func_t *func, void *data);

void can_recv_start(can_recv_t *recv, can_net_t *net, uint_least32_t id,
                uint_least8_t flags);

void can_recv_stop(can_recv_t *recv);
 
#ifdef __cplusplus
}
#endif
 
#endif // !LELY_CAN_NET_H_