zbus.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Rodrigo Peixoto <rodrigopex@gmail.com>
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_ZBUS_H_
#define ZEPHYR_INCLUDE_ZBUS_H_
 
#include <string.h>
 
#include <zephyr/kernel.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct zbus_channel {
#if defined(CONFIG_ZBUS_CHANNEL_NAME) || defined(__DOXYGEN__)
        const char *const name;
#endif
        const uint16_t message_size;
 
        void *const user_data;
 
        void *const message;
 
        bool (*const validator)(const void *msg, size_t msg_size);
 
        struct k_mutex *mutex;
#if (CONFIG_ZBUS_RUNTIME_OBSERVERS_POOL_SIZE > 0) || defined(__DOXYGEN__)
        sys_slist_t *runtime_observers;
#endif /* CONFIG_ZBUS_RUNTIME_OBSERVERS_POOL_SIZE  */
 
        const struct zbus_observer *const *observers;
};
 
struct zbus_observer {
#if defined(CONFIG_ZBUS_OBSERVER_NAME) || defined(__DOXYGEN__)
        const char *const name;
#endif
        bool enabled;
        struct k_msgq *const queue;
 
        void (*const callback)(const struct zbus_channel *chan);
};
 
#if defined(CONFIG_ZBUS_ASSERT_MOCK)
#define _ZBUS_ASSERT(_cond, _fmt, ...)                                                             \
        do {                                                                                       \
                if (!(_cond)) {                                                                    \
                        printk("ZBUS ASSERT: ");                                                   \
                        printk(_fmt, ##__VA_ARGS__);                                               \
                        printk("\n");                                                              \
                        return -EFAULT;                                                            \
                }                                                                                  \
        } while (0)
#else
#define _ZBUS_ASSERT(_cond, _fmt, ...) __ASSERT(_cond, _fmt, ##__VA_ARGS__)
#endif
 
#if defined(CONFIG_ZBUS_CHANNEL_NAME)
#define ZBUS_CHANNEL_NAME_INIT(_name) .name = #_name,
#else
#define ZBUS_CHANNEL_NAME_INIT(_name)
#endif
 
#if defined(CONFIG_ZBUS_OBSERVER_NAME)
#define ZBUS_OBSERVER_NAME_INIT(_name) .name = #_name,
#define _ZBUS_OBS_NAME(_obs)           (_obs)->name
#else
#define ZBUS_OBSERVER_NAME_INIT(_name)
#define _ZBUS_OBS_NAME(_obs) ""
#endif
 
#if CONFIG_ZBUS_RUNTIME_OBSERVERS_POOL_SIZE > 0
#define ZBUS_RUNTIME_OBSERVERS_LIST_DECL(_slist_name) static sys_slist_t _slist_name
#define ZBUS_RUNTIME_OBSERVERS_LIST_INIT(_slist_name) .runtime_observers = &_slist_name,
#else
#define ZBUS_RUNTIME_OBSERVERS_LIST_DECL(_slist_name)
#define ZBUS_RUNTIME_OBSERVERS_LIST_INIT(_slist_name) /* No runtime observers */
#endif
 
#if defined(CONFIG_ZBUS_STRUCTS_ITERABLE_ACCESS)
#define _ZBUS_STRUCT_DECLARE(_type, _name) STRUCT_SECTION_ITERABLE(_type, _name)
#else
#define _ZBUS_STRUCT_DECLARE(_type, _name) struct _type _name
#endif /* CONFIG_ZBUS_STRUCTS_ITERABLE_ACCESS */
 
#define _ZBUS_OBS_EXTERN(_name) extern struct zbus_observer _name
 
#define _ZBUS_CHAN_EXTERN(_name) extern const struct zbus_channel _name
 
#define ZBUS_REF(_value) &(_value)
 
k_timeout_t _zbus_timeout_remainder(uint64_t end_ticks);
#define ZBUS_OBS_DECLARE(...) FOR_EACH(_ZBUS_OBS_EXTERN, (;), __VA_ARGS__)
 
#define ZBUS_CHAN_DECLARE(...) FOR_EACH(_ZBUS_CHAN_EXTERN, (;), __VA_ARGS__)
 
#define ZBUS_OBSERVERS_EMPTY
 
#define ZBUS_OBSERVERS(...) __VA_ARGS__
 
#define ZBUS_CHAN_DEFINE(_name, _type, _validator, _user_data, _observers, _init_val)        \
        static _type _CONCAT(_zbus_message_, _name) = _init_val;                             \
        static K_MUTEX_DEFINE(_CONCAT(_zbus_mutex_, _name));                                 \
        ZBUS_RUNTIME_OBSERVERS_LIST_DECL(_CONCAT(_runtime_observers_, _name));               \
        FOR_EACH_NONEMPTY_TERM(_ZBUS_OBS_EXTERN, (;), _observers)                            \
        static const struct zbus_observer *const _CONCAT(_zbus_observers_, _name)[] = {      \
        FOR_EACH_NONEMPTY_TERM(ZBUS_REF, (,), _observers) NULL};                             \
        const _ZBUS_STRUCT_DECLARE(zbus_channel, _name) = {                                  \
                ZBUS_CHANNEL_NAME_INIT(_name)                  /* Name */                    \
                .message_size = sizeof(_type),                 /* Message size */            \
                .user_data = _user_data,                       /* User data */               \
                .message = &_CONCAT(_zbus_message_, _name),    /* Reference to the message */\
                .validator = (_validator),                     /* Validator function */      \
                .mutex = &_CONCAT(_zbus_mutex_, _name),        /* Channel's Mutex */         \
                ZBUS_RUNTIME_OBSERVERS_LIST_INIT(                                            \
                        _CONCAT(_runtime_observers_, _name))   /* Runtime observer list */   \
                .observers = _CONCAT(_zbus_observers_, _name)} /* Static observer list */
 
#define ZBUS_MSG_INIT(_val, ...)                                                                   \
        {                                                                                          \
                _val, ##__VA_ARGS__                                                                \
        }
 
#define ZBUS_SUBSCRIBER_DEFINE(_name, _queue_size)                                                 \
        K_MSGQ_DEFINE(_zbus_observer_queue_##_name, sizeof(const struct zbus_channel *),           \
                      _queue_size, sizeof(const struct zbus_channel *));                           \
        _ZBUS_STRUCT_DECLARE(zbus_observer,                                                        \
                             _name) = {ZBUS_OBSERVER_NAME_INIT(_name) /* Name field */             \
                                               .enabled = true,                                    \
                                       .queue = &_zbus_observer_queue_##_name, .callback = NULL}
 
#define ZBUS_LISTENER_DEFINE(_name, _cb)                                                           \
        _ZBUS_STRUCT_DECLARE(zbus_observer,                                                        \
                             _name) = {ZBUS_OBSERVER_NAME_INIT(_name) /* Name field */             \
                                               .enabled = true,                                    \
                                       .queue = NULL, .callback = (_cb)}
 
int zbus_chan_pub(const struct zbus_channel *chan, const void *msg, k_timeout_t timeout);
 
int zbus_chan_read(const struct zbus_channel *chan, void *msg, k_timeout_t timeout);
 
int zbus_chan_claim(const struct zbus_channel *chan, k_timeout_t timeout);
 
int zbus_chan_finish(const struct zbus_channel *chan);
 
int zbus_chan_notify(const struct zbus_channel *chan, k_timeout_t timeout);
 
#if defined(CONFIG_ZBUS_CHANNEL_NAME) || defined(__DOXYGEN__)
 
static inline const char *zbus_chan_name(const struct zbus_channel *chan)
{
        __ASSERT(chan != NULL, "chan is required");
 
        return chan->name;
}
 
#endif
 
static inline void *zbus_chan_msg(const struct zbus_channel *chan)
{
        __ASSERT(chan != NULL, "chan is required");
 
        return chan->message;
}
 
static inline const void *zbus_chan_const_msg(const struct zbus_channel *chan)
{
        __ASSERT(chan != NULL, "chan is required");
 
        return chan->message;
}
 
static inline uint16_t zbus_chan_msg_size(const struct zbus_channel *chan)
{
        __ASSERT(chan != NULL, "chan is required");
 
        return chan->message_size;
}
 
static inline void *zbus_chan_user_data(const struct zbus_channel *chan)
{
        __ASSERT(chan != NULL, "chan is required");
 
        return chan->user_data;
}
 
#if (CONFIG_ZBUS_RUNTIME_OBSERVERS_POOL_SIZE > 0) || defined(__DOXYGEN__)
 
int zbus_chan_add_obs(const struct zbus_channel *chan, const struct zbus_observer *obs,
                      k_timeout_t timeout);
 
int zbus_chan_rm_obs(const struct zbus_channel *chan, const struct zbus_observer *obs,
                     k_timeout_t timeout);
 
struct k_mem_slab *zbus_runtime_obs_pool(void);
 
struct zbus_observer_node {
        sys_snode_t node;
        const struct zbus_observer *obs;
};
 
#endif /* CONFIG_ZBUS_RUNTIME_OBSERVERS_POOL_SIZE */
 
static inline int zbus_obs_set_enable(struct zbus_observer *obs, bool enabled)
{
        _ZBUS_ASSERT(obs != NULL, "obs is required");
 
        obs->enabled = enabled;
 
        return 0;
}
 
#if defined(CONFIG_ZBUS_OBSERVER_NAME) || defined(__DOXYGEN__)
 
static inline const char *zbus_obs_name(const struct zbus_observer *obs)
{
        __ASSERT(obs != NULL, "obs is required");
 
        return obs->name;
}
 
#endif
 
int zbus_sub_wait(const struct zbus_observer *sub, const struct zbus_channel **chan,
                  k_timeout_t timeout);
 
#if defined(CONFIG_ZBUS_STRUCTS_ITERABLE_ACCESS) || defined(__DOXYGEN__)
bool zbus_iterate_over_channels(bool (*iterator_func)(const struct zbus_channel *chan));
 
bool zbus_iterate_over_observers(bool (*iterator_func)(const struct zbus_observer *obs));
 
#endif /* CONFIG_ZBUS_STRUCTS_ITERABLE_ACCESS */
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_ZBUS_H_ */