light_ctrl_srv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BT_MESH_LIGHT_CTRL_SRV_H__
#define BT_MESH_LIGHT_CTRL_SRV_H__
 
#include <zephyr/bluetooth/mesh.h>
#include <bluetooth/mesh/light_ctrl.h>
#include <bluetooth/mesh/sensor.h>
#include <bluetooth/mesh/gen_onoff_srv.h>
#include <bluetooth/mesh/lightness_srv.h>
#include <bluetooth/mesh/model_types.h>
#include <bluetooth/mesh/light_ctrl_reg.h>
#include <bluetooth/mesh/light_ctrl_reg_spec.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct bt_mesh_light_ctrl_srv;
 
#if defined(CONFIG_BT_MESH_LIGHT_CTRL_SRV_REG)
#define BT_MESH_LIGHT_CTRL_SRV_INIT_WITH_REG(_lightness_srv, _reg)             \
        {                                                                      \
                .cfg = BT_MESH_LIGHT_CTRL_SRV_CFG_INIT,                        \
                .onoff = BT_MESH_ONOFF_SRV_INIT(                               \
                        &_bt_mesh_light_ctrl_srv_onoff),                       \
                .lightness = _lightness_srv,                                   \
                .reg = _reg                                                    \
        }
#endif
 
#if CONFIG_BT_MESH_LIGHT_CTRL_REG_SPEC && CONFIG_BT_MESH_LIGHT_CTRL_SRV_REG
#define BT_MESH_LIGHT_CTRL_SRV_INIT(_lightness_srv)                            \
        BT_MESH_LIGHT_CTRL_SRV_INIT_WITH_REG(                                  \
                _lightness_srv,                                                \
                &(&((struct bt_mesh_light_ctrl_reg_spec)                       \
                    BT_MESH_LIGHT_CTRL_REG_SPEC_INIT))->reg)
#else
#define BT_MESH_LIGHT_CTRL_SRV_INIT(_lightness_srv)                            \
        {                                                                      \
                .cfg = BT_MESH_LIGHT_CTRL_SRV_CFG_INIT,                        \
                .onoff = BT_MESH_ONOFF_SRV_INIT(                               \
                        &_bt_mesh_light_ctrl_srv_onoff),                       \
                .lightness = _lightness_srv                                    \
        }
#endif
 
#define BT_MESH_MODEL_LIGHT_CTRL_SRV(_srv)                                     \
        BT_MESH_MODEL_ONOFF_SRV(&(_srv)->onoff),                               \
        BT_MESH_MODEL_CB(BT_MESH_MODEL_ID_LIGHT_LC_SRV,                        \
                         _bt_mesh_light_ctrl_srv_op, &(_srv)->pub,             \
                         BT_MESH_MODEL_USER_DATA(                              \
                                 struct bt_mesh_light_ctrl_srv, _srv),         \
                         &_bt_mesh_light_ctrl_srv_cb),                         \
        BT_MESH_MODEL_CB(BT_MESH_MODEL_ID_LIGHT_LC_SETUPSRV,                   \
                         _bt_mesh_light_ctrl_setup_srv_op,                     \
                         &(_srv)->setup_pub,                                   \
                         BT_MESH_MODEL_USER_DATA(                              \
                                 struct bt_mesh_light_ctrl_srv, _srv),         \
                         &_bt_mesh_light_ctrl_setup_srv_cb)
 
enum bt_mesh_light_ctrl_srv_state {
        LIGHT_CTRL_STATE_STANDBY,
        LIGHT_CTRL_STATE_ON,
        LIGHT_CTRL_STATE_PROLONG,
 
        LIGHT_CTRL_STATE_COUNT,
};
 
struct bt_mesh_light_ctrl_srv_cfg {
        uint32_t occupancy_delay;
        uint32_t fade_on;
        uint32_t on;
        uint32_t fade_prolong;
        uint32_t prolong;
        uint32_t fade_standby_auto;
        uint32_t fade_standby_manual;
        uint16_t light[LIGHT_CTRL_STATE_COUNT];
#if CONFIG_BT_MESH_LIGHT_CTRL_SRV_REG
        uint32_t centilux[LIGHT_CTRL_STATE_COUNT];
#endif /* CONFIG_BT_MESH_LIGHT_CTRL_SRV_REG */
};
 
struct bt_mesh_light_ctrl_srv {
        enum bt_mesh_light_ctrl_srv_state state;
        atomic_t flags;
        struct {
                uint16_t initial_light;
                uint32_t initial_centilux;
                uint32_t duration;
        } fade;
        struct k_work_delayable timer;
 
        struct k_work_delayable action_delay;
        struct bt_mesh_light_ctrl_srv_cfg cfg;
        struct bt_mesh_model_pub pub;
        /* Publication buffer */
        struct net_buf_simple pub_buf;
        /* Publication data */
        uint8_t pub_data[BT_MESH_MODEL_BUF_LEN(
                BT_MESH_LIGHT_CTRL_OP_LIGHT_ONOFF_STATUS, 3)];
        uint16_t resume;
#if CONFIG_BT_MESH_LIGHT_CTRL_AMB_LIGHT_LEVEL_TIMEOUT
        /* Time when the last ambient light level report was received. */
        int64_t amb_light_level_timestamp;
#endif
        struct bt_mesh_model_pub setup_pub;
        /* Publication buffer */
        struct net_buf_simple setup_pub_buf;
        /* Publication data */
        uint8_t setup_pub_data[BT_MESH_MODEL_BUF_LEN(
                BT_MESH_LIGHT_CTRL_OP_PROP_STATUS,
                2 + CONFIG_BT_MESH_SENSOR_CHANNEL_ENCODED_SIZE_MAX)];
 
#if CONFIG_BT_MESH_LIGHT_CTRL_SRV_REG
        struct bt_mesh_light_ctrl_reg *reg;
        uint16_t reg_prev;
#endif /* CONFIG_BT_MESH_LIGHT_CTRL_SRV_REG */
        struct bt_mesh_lightness_srv *lightness;
        struct bt_mesh_onoff_srv onoff;
        struct bt_mesh_tid_ctx tid;
        const struct bt_mesh_model *model;
        const struct bt_mesh_model *setup_srv;
};
 
int bt_mesh_light_ctrl_srv_on(struct bt_mesh_light_ctrl_srv *srv);
 
int bt_mesh_light_ctrl_srv_off(struct bt_mesh_light_ctrl_srv *srv);
 
int bt_mesh_light_ctrl_srv_enable(struct bt_mesh_light_ctrl_srv *srv);
 
int bt_mesh_light_ctrl_srv_disable(struct bt_mesh_light_ctrl_srv *srv);
 
bool bt_mesh_light_ctrl_srv_is_on(struct bt_mesh_light_ctrl_srv *srv);
 
int bt_mesh_light_ctrl_srv_pub(struct bt_mesh_light_ctrl_srv *srv,
                               struct bt_mesh_msg_ctx *ctx);
 
extern const struct bt_mesh_model_cb _bt_mesh_light_ctrl_srv_cb;
extern const struct bt_mesh_model_op _bt_mesh_light_ctrl_srv_op[];
extern const struct bt_mesh_model_cb _bt_mesh_light_ctrl_setup_srv_cb;
extern const struct bt_mesh_model_op _bt_mesh_light_ctrl_setup_srv_op[];
extern const struct bt_mesh_onoff_srv_handlers _bt_mesh_light_ctrl_srv_onoff;
#ifdef __cplusplus
}
#endif
 
#endif /* BT_MESH_LIGHT_CTRL_SRV_H__ */