access.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_MESH_ACCESS_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_ACCESS_H_
 
#include <settings/settings.h>
#include <sys/util.h>
#include <bluetooth/mesh/msg.h>
 
/* Internal macros used to initialize array members */
#define BT_MESH_KEY_UNUSED_ELT_(IDX, _) BT_MESH_KEY_UNUSED,
#define BT_MESH_ADDR_UNASSIGNED_ELT_(IDX, _) BT_MESH_ADDR_UNASSIGNED,
#define BT_MESH_MODEL_KEYS_UNUSED                       \
        { UTIL_LISTIFY(CONFIG_BT_MESH_MODEL_KEY_COUNT,  \
                       BT_MESH_KEY_UNUSED_ELT_) }
#define BT_MESH_MODEL_GROUPS_UNASSIGNED                         \
        { UTIL_LISTIFY(CONFIG_BT_MESH_MODEL_GROUP_COUNT,        \
                       BT_MESH_ADDR_UNASSIGNED_ELT_) }
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BT_MESH_ADDR_UNASSIGNED   0x0000
#define BT_MESH_ADDR_ALL_NODES    0xffff
#define BT_MESH_ADDR_PROXIES      0xfffc
#define BT_MESH_ADDR_FRIENDS      0xfffd
#define BT_MESH_ADDR_RELAYS       0xfffe
 
#define BT_MESH_KEY_UNUSED        0xffff
#define BT_MESH_KEY_ANY           0xffff
#define BT_MESH_KEY_DEV           0xfffe
#define BT_MESH_KEY_DEV_LOCAL     BT_MESH_KEY_DEV
#define BT_MESH_KEY_DEV_REMOTE    0xfffd
#define BT_MESH_KEY_DEV_ANY       0xfffc
 
#define BT_MESH_ADDR_IS_UNICAST(addr) ((addr) && (addr) < 0x8000)
#define BT_MESH_ADDR_IS_GROUP(addr) ((addr) >= 0xc000 && (addr) <= 0xff00)
#define BT_MESH_ADDR_IS_VIRTUAL(addr) ((addr) >= 0x8000 && (addr) < 0xc000)
#define BT_MESH_ADDR_IS_RFU(addr) ((addr) >= 0xff00 && (addr) <= 0xfffb)
 
#define BT_MESH_IS_DEV_KEY(key) (key == BT_MESH_KEY_DEV_LOCAL || \
                                 key == BT_MESH_KEY_DEV_REMOTE)
 
#define BT_MESH_APP_SEG_SDU_MAX   12
#define BT_MESH_TX_SDU_MAX        (CONFIG_BT_MESH_TX_SEG_MAX * \
                                  BT_MESH_APP_SEG_SDU_MAX)
#define BT_MESH_RX_SDU_MAX        (CONFIG_BT_MESH_RX_SEG_MAX * \
                                  BT_MESH_APP_SEG_SDU_MAX)
 
#define BT_MESH_ELEM(_loc, _mods, _vnd_mods)        \
{                                                   \
        .loc              = (_loc),                 \
        .model_count      = ARRAY_SIZE(_mods),      \
        .vnd_model_count  = ARRAY_SIZE(_vnd_mods),  \
        .models           = (_mods),                \
        .vnd_models       = (_vnd_mods),            \
}
 
struct bt_mesh_elem {
        uint16_t addr;
 
        const uint16_t loc;
        const uint8_t model_count;
        const uint8_t vnd_model_count;
 
        struct bt_mesh_model * const models;
        struct bt_mesh_model * const vnd_models;
};
 
/* Foundation Models */
#define BT_MESH_MODEL_ID_CFG_SRV                   0x0000
#define BT_MESH_MODEL_ID_CFG_CLI                   0x0001
#define BT_MESH_MODEL_ID_HEALTH_SRV                0x0002
#define BT_MESH_MODEL_ID_HEALTH_CLI                0x0003
 
/* Models from the Mesh Model Specification */
#define BT_MESH_MODEL_ID_GEN_ONOFF_SRV             0x1000
#define BT_MESH_MODEL_ID_GEN_ONOFF_CLI             0x1001
#define BT_MESH_MODEL_ID_GEN_LEVEL_SRV             0x1002
#define BT_MESH_MODEL_ID_GEN_LEVEL_CLI             0x1003
#define BT_MESH_MODEL_ID_GEN_DEF_TRANS_TIME_SRV    0x1004
#define BT_MESH_MODEL_ID_GEN_DEF_TRANS_TIME_CLI    0x1005
#define BT_MESH_MODEL_ID_GEN_POWER_ONOFF_SRV       0x1006
#define BT_MESH_MODEL_ID_GEN_POWER_ONOFF_SETUP_SRV 0x1007
#define BT_MESH_MODEL_ID_GEN_POWER_ONOFF_CLI       0x1008
#define BT_MESH_MODEL_ID_GEN_POWER_LEVEL_SRV       0x1009
#define BT_MESH_MODEL_ID_GEN_POWER_LEVEL_SETUP_SRV 0x100a
#define BT_MESH_MODEL_ID_GEN_POWER_LEVEL_CLI       0x100b
#define BT_MESH_MODEL_ID_GEN_BATTERY_SRV           0x100c
#define BT_MESH_MODEL_ID_GEN_BATTERY_CLI           0x100d
#define BT_MESH_MODEL_ID_GEN_LOCATION_SRV          0x100e
#define BT_MESH_MODEL_ID_GEN_LOCATION_SETUPSRV     0x100f
#define BT_MESH_MODEL_ID_GEN_LOCATION_CLI          0x1010
#define BT_MESH_MODEL_ID_GEN_ADMIN_PROP_SRV        0x1011
#define BT_MESH_MODEL_ID_GEN_MANUFACTURER_PROP_SRV 0x1012
#define BT_MESH_MODEL_ID_GEN_USER_PROP_SRV         0x1013
#define BT_MESH_MODEL_ID_GEN_CLIENT_PROP_SRV       0x1014
#define BT_MESH_MODEL_ID_GEN_PROP_CLI              0x1015
#define BT_MESH_MODEL_ID_SENSOR_SRV                0x1100
#define BT_MESH_MODEL_ID_SENSOR_SETUP_SRV          0x1101
#define BT_MESH_MODEL_ID_SENSOR_CLI                0x1102
#define BT_MESH_MODEL_ID_TIME_SRV                  0x1200
#define BT_MESH_MODEL_ID_TIME_SETUP_SRV            0x1201
#define BT_MESH_MODEL_ID_TIME_CLI                  0x1202
#define BT_MESH_MODEL_ID_SCENE_SRV                 0x1203
#define BT_MESH_MODEL_ID_SCENE_SETUP_SRV           0x1204
#define BT_MESH_MODEL_ID_SCENE_CLI                 0x1205
#define BT_MESH_MODEL_ID_SCHEDULER_SRV             0x1206
#define BT_MESH_MODEL_ID_SCHEDULER_SETUP_SRV       0x1207
#define BT_MESH_MODEL_ID_SCHEDULER_CLI             0x1208
#define BT_MESH_MODEL_ID_LIGHT_LIGHTNESS_SRV       0x1300
#define BT_MESH_MODEL_ID_LIGHT_LIGHTNESS_SETUP_SRV 0x1301
#define BT_MESH_MODEL_ID_LIGHT_LIGHTNESS_CLI       0x1302
#define BT_MESH_MODEL_ID_LIGHT_CTL_SRV             0x1303
#define BT_MESH_MODEL_ID_LIGHT_CTL_SETUP_SRV       0x1304
#define BT_MESH_MODEL_ID_LIGHT_CTL_CLI             0x1305
#define BT_MESH_MODEL_ID_LIGHT_CTL_TEMP_SRV        0x1306
#define BT_MESH_MODEL_ID_LIGHT_HSL_SRV             0x1307
#define BT_MESH_MODEL_ID_LIGHT_HSL_SETUP_SRV       0x1308
#define BT_MESH_MODEL_ID_LIGHT_HSL_CLI             0x1309
#define BT_MESH_MODEL_ID_LIGHT_HSL_HUE_SRV         0x130a
#define BT_MESH_MODEL_ID_LIGHT_HSL_SAT_SRV         0x130b
#define BT_MESH_MODEL_ID_LIGHT_XYL_SRV             0x130c
#define BT_MESH_MODEL_ID_LIGHT_XYL_SETUP_SRV       0x130d
#define BT_MESH_MODEL_ID_LIGHT_XYL_CLI             0x130e
#define BT_MESH_MODEL_ID_LIGHT_LC_SRV              0x130f
#define BT_MESH_MODEL_ID_LIGHT_LC_SETUPSRV         0x1310
#define BT_MESH_MODEL_ID_LIGHT_LC_CLI              0x1311
 
struct bt_mesh_model_op {
        const uint32_t  opcode;
 
        const ssize_t len;
 
        int (*const func)(struct bt_mesh_model *model,
                          struct bt_mesh_msg_ctx *ctx,
                          struct net_buf_simple *buf);
};
 
#define BT_MESH_MODEL_OP_1(b0) (b0)
#define BT_MESH_MODEL_OP_2(b0, b1) (((b0) << 8) | (b1))
#define BT_MESH_MODEL_OP_3(b0, cid) ((((b0) << 16) | 0xc00000) | (cid))
 
#define BT_MESH_LEN_EXACT(len) (-len)
#define BT_MESH_LEN_MIN(len) (len)
 
#define BT_MESH_MODEL_OP_END { 0, 0, NULL }
#define BT_MESH_MODEL_NO_OPS ((struct bt_mesh_model_op []) \
                              { BT_MESH_MODEL_OP_END })
 
#define BT_MESH_MODEL_NONE ((struct bt_mesh_model []){})
 
#define BT_MESH_MODEL_CB(_id, _op, _pub, _user_data, _cb)                    \
{                                                                            \
        .id = (_id),                                                         \
        .pub = _pub,                                                         \
        .keys = BT_MESH_MODEL_KEYS_UNUSED,                                   \
        .groups = BT_MESH_MODEL_GROUPS_UNASSIGNED,                           \
        .op = _op,                                                           \
        .cb = _cb,                                                           \
        .user_data = _user_data,                                             \
}
 
#define BT_MESH_MODEL_VND_CB(_company, _id, _op, _pub, _user_data, _cb)      \
{                                                                            \
        .vnd.company = (_company),                                           \
        .vnd.id = (_id),                                                     \
        .op = _op,                                                           \
        .pub = _pub,                                                         \
        .keys = BT_MESH_MODEL_KEYS_UNUSED,                                   \
        .groups = BT_MESH_MODEL_GROUPS_UNASSIGNED,                           \
        .user_data = _user_data,                                             \
        .cb = _cb,                                                           \
}
 
 
#define BT_MESH_MODEL(_id, _op, _pub, _user_data)                              \
        BT_MESH_MODEL_CB(_id, _op, _pub, _user_data, NULL)
 
#define BT_MESH_MODEL_VND(_company, _id, _op, _pub, _user_data)                \
        BT_MESH_MODEL_VND_CB(_company, _id, _op, _pub, _user_data, NULL)
 
#define BT_MESH_TRANSMIT(count, int_ms) ((count) | (((int_ms / 10) - 1) << 3))
 
#define BT_MESH_TRANSMIT_COUNT(transmit) (((transmit) & (uint8_t)BIT_MASK(3)))
 
#define BT_MESH_TRANSMIT_INT(transmit) ((((transmit) >> 3) + 1) * 10)
 
#define BT_MESH_PUB_TRANSMIT(count, int_ms) BT_MESH_TRANSMIT(count,           \
                                                             (int_ms) / 5)
 
#define BT_MESH_PUB_TRANSMIT_COUNT(transmit) BT_MESH_TRANSMIT_COUNT(transmit)
 
#define BT_MESH_PUB_TRANSMIT_INT(transmit) ((((transmit) >> 3) + 1) * 50)
 
struct bt_mesh_model_pub {
        struct bt_mesh_model *mod;
 
        uint16_t addr;          
        uint16_t key:12,        
                 cred:1,        
                 send_rel:1,    
                 fast_period:1; 
        uint8_t  ttl;          
        uint8_t  retransmit;   
        uint8_t  period;       
        uint8_t  period_div:4, 
                 count:4;      
        uint32_t period_start; 
        struct net_buf_simple *msg;
 
        int (*update)(struct bt_mesh_model *mod);
 
        struct k_work_delayable timer;
};
 
#define BT_MESH_MODEL_PUB_DEFINE(_name, _update, _msg_len) \
        NET_BUF_SIMPLE_DEFINE_STATIC(bt_mesh_pub_msg_##_name, _msg_len); \
        static struct bt_mesh_model_pub _name = { \
                .msg = &bt_mesh_pub_msg_##_name, \
                .update = _update, \
        }
 
struct bt_mesh_model_cb {
        int (*const settings_set)(struct bt_mesh_model *model,
                                  const char *name, size_t len_rd,
                                  settings_read_cb read_cb, void *cb_arg);
 
        int (*const start)(struct bt_mesh_model *model);
 
        int (*const init)(struct bt_mesh_model *model);
 
        void (*const reset)(struct bt_mesh_model *model);
};
 
struct bt_mesh_mod_id_vnd {
        uint16_t company;
        uint16_t id;
};
 
struct bt_mesh_model {
        union {
                const uint16_t id;
                const struct bt_mesh_mod_id_vnd vnd;
        };
 
        /* Internal information, mainly for persistent storage */
        uint8_t  elem_idx;   /* Belongs to Nth element */
        uint8_t  mod_idx;    /* Is the Nth model in the element */
        uint16_t flags;      /* Model flags for internal bookkeeping */
 
        struct bt_mesh_model_pub * const pub;
 
        uint16_t keys[CONFIG_BT_MESH_MODEL_KEY_COUNT];
 
        uint16_t groups[CONFIG_BT_MESH_MODEL_GROUP_COUNT];
 
        const struct bt_mesh_model_op * const op;
 
        const struct bt_mesh_model_cb * const cb;
 
#ifdef CONFIG_BT_MESH_MODEL_EXTENSIONS
        /* Pointer to the next model in a model extension list. */
        struct bt_mesh_model *next;
#endif
 
        void *user_data;
};
 
struct bt_mesh_send_cb {
        void (*start)(uint16_t duration, int err, void *cb_data);
        void (*end)(int err, void *cb_data);
};
 
 
#define BT_MESH_TTL_DEFAULT 0xff
 
#define BT_MESH_TTL_MAX     0x7f
 
int bt_mesh_model_send(struct bt_mesh_model *model,
                       struct bt_mesh_msg_ctx *ctx,
                       struct net_buf_simple *msg,
                       const struct bt_mesh_send_cb *cb,
                       void *cb_data);
 
int bt_mesh_model_publish(struct bt_mesh_model *model);
 
struct bt_mesh_elem *bt_mesh_model_elem(struct bt_mesh_model *mod);
 
struct bt_mesh_model *bt_mesh_model_find(const struct bt_mesh_elem *elem,
                                         uint16_t id);
 
struct bt_mesh_model *bt_mesh_model_find_vnd(const struct bt_mesh_elem *elem,
                                             uint16_t company, uint16_t id);
 
static inline bool bt_mesh_model_in_primary(const struct bt_mesh_model *mod)
{
        return (mod->elem_idx == 0);
}
 
int bt_mesh_model_data_store(struct bt_mesh_model *mod, bool vnd,
                             const char *name, const void *data,
                             size_t data_len);
 
int bt_mesh_model_extend(struct bt_mesh_model *extending_mod,
                         struct bt_mesh_model *base_mod);
 
bool bt_mesh_model_is_extended(struct bt_mesh_model *model);
 
struct bt_mesh_comp {
        uint16_t cid; 
        uint16_t pid; 
        uint16_t vid; 
        size_t elem_count; 
        struct bt_mesh_elem *elem; 
};
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_ACCESS_H_ */