1085 lines
30 KiB
C
1085 lines
30 KiB
C
#include "adaptation.h"
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include "net.h"
|
||
#include "transport.h"
|
||
#include "api/sensor.h"
|
||
#include "api/sensor_cli.h"
|
||
#include "api/properties.h"
|
||
#include "api/sensor_types.h"
|
||
#include <access.h>
|
||
#include "msg.h"
|
||
|
||
#if (CONFIG_BT_MESH_SENSOR_CLI)
|
||
|
||
#define LOG_TAG "[Mesh-sensor_cli]"
|
||
#define LOG_ERROR_ENABLE
|
||
#define LOG_DEBUG_ENABLE
|
||
#define LOG_INFO_ENABLE
|
||
/* #define LOG_DUMP_ENABLE */
|
||
#define LOG_CLI_ENABLE
|
||
#include "debug.h"
|
||
|
||
struct list_rsp {
|
||
struct bt_mesh_sensor_info *sensors;
|
||
uint32_t count;
|
||
};
|
||
|
||
struct settings_rsp {
|
||
uint16_t id;
|
||
uint16_t *ids;
|
||
uint32_t count;
|
||
};
|
||
|
||
struct setting_rsp {
|
||
uint16_t id;
|
||
uint16_t setting_id;
|
||
struct bt_mesh_sensor_setting_status *setting;
|
||
};
|
||
|
||
struct sensor_data_list_rsp {
|
||
struct bt_mesh_sensor_data *sensors;
|
||
uint32_t count;
|
||
};
|
||
|
||
struct series_data_rsp {
|
||
struct bt_mesh_sensor_series_entry *entries;
|
||
const struct bt_mesh_sensor_column *col;
|
||
uint16_t id;
|
||
uint32_t count;
|
||
};
|
||
|
||
struct cadence_rsp {
|
||
uint16_t id;
|
||
struct bt_mesh_sensor_cadence_status *cadence;
|
||
};
|
||
|
||
const struct bt_mesh_sensor_type *bt_mesh_sensor_type_get(uint16_t id)
|
||
{
|
||
// 遍历传感器类型列表
|
||
for (size_t i = 0; i < SENSOR_TYPE_LIST_SIZE; i++) {
|
||
if (sensor_type_list[i]->id == id) {
|
||
return sensor_type_list[i];
|
||
}
|
||
}
|
||
|
||
// 如果找不到匹配的 ID，返回 NULL
|
||
return NULL;
|
||
}
|
||
|
||
|
||
static void unknown_type(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx, uint16_t id, uint32_t op)
|
||
{
|
||
if (cli->cb && cli->cb->unknown_type) {
|
||
cli->cb->unknown_type(cli, ctx, id, op);
|
||
}
|
||
}
|
||
|
||
static int handle_descriptor_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
if (buf->len != 2 && buf->len % 8) {
|
||
return -EMSGSIZE;
|
||
}
|
||
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
struct list_rsp *ack_ctx = NULL;
|
||
uint32_t count = 0;
|
||
|
||
(void)bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_DESCRIPTOR_STATUS,
|
||
ctx->addr, (void **)&ack_ctx);
|
||
|
||
/* A packet with only the sensor ID means that the given sensor doesn't
|
||
* exist on the sensor server.
|
||
*/
|
||
if (buf->len == 2) {
|
||
goto yield_ack;
|
||
}
|
||
|
||
struct bt_mesh_sensor_info sensor;
|
||
|
||
while (buf->len >= 8) {
|
||
|
||
sensor_descriptor_decode(buf, &sensor);
|
||
|
||
if (cli->cb && cli->cb->sensor) {
|
||
cli->cb->sensor(cli, ctx, &sensor);
|
||
}
|
||
|
||
if (ack_ctx && count < ack_ctx->count) {
|
||
ack_ctx->sensors[count++] = sensor;
|
||
}
|
||
}
|
||
|
||
yield_ack:
|
||
if (ack_ctx) {
|
||
ack_ctx->count = count;
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int handle_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
struct sensor_data_list_rsp *rsp = NULL;
|
||
uint32_t count = 0;
|
||
int err;
|
||
|
||
(void)bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_STATUS, ctx->addr,
|
||
(void **)&rsp);
|
||
log_debug_hexdump(buf->data, buf->len);
|
||
while (buf->len) {
|
||
const struct bt_mesh_sensor_type *type;
|
||
uint8_t length;
|
||
uint16_t id;
|
||
|
||
sensor_status_id_decode(buf, &length, &id);
|
||
|
||
if (length == 0) {
|
||
if (rsp && rsp->count == 1 && rsp->sensors[0].type &&
|
||
rsp->sensors[0].type->id == id) {
|
||
rsp->sensors[0].type = NULL;
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
rsp = NULL;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
type = bt_mesh_sensor_type_get(id);
|
||
if (!type) {
|
||
if (buf->len < length) {
|
||
log_error("Invalid length for 0x%04x: %u", id,
|
||
length);
|
||
return -EMSGSIZE;
|
||
}
|
||
net_buf_simple_pull(buf, length);
|
||
unknown_type(cli, ctx, id, BT_MESH_SENSOR_OP_STATUS);
|
||
continue;
|
||
}
|
||
|
||
uint8_t expected_len = sensor_value_len(type);
|
||
if (length != expected_len) {
|
||
log_error("Invalid length for 0x%04x: %u (expected %u)",
|
||
id, length, expected_len);
|
||
return -EMSGSIZE;
|
||
}
|
||
|
||
struct sensor_value value[CONFIG_BT_MESH_SENSOR_CHANNELS_MAX];
|
||
err = sensor_value_decode(buf, type, value);
|
||
if (err) {
|
||
log_error("Invalid format, err=%d", err);
|
||
return err; /* Invalid format, should ignore message */
|
||
}
|
||
if (cli->cb && cli->cb->data) {
|
||
cli->cb->data(cli, ctx, type, value);
|
||
}
|
||
|
||
if (rsp && count <= rsp->count) {
|
||
memcpy(rsp->sensors[count].value, value,
|
||
sizeof(struct sensor_value) *
|
||
type->channel_count);
|
||
|
||
rsp->sensors[count].type = type;
|
||
++count;
|
||
}
|
||
}
|
||
|
||
if (rsp) {
|
||
rsp->count = count;
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int parse_series_entry(const struct bt_mesh_sensor_type *type,
|
||
const struct bt_mesh_sensor_format *col_format,
|
||
struct net_buf_simple *buf,
|
||
struct bt_mesh_sensor_series_entry *entry)
|
||
{
|
||
if (col_format == NULL) {
|
||
// Indexed column, decode only value
|
||
memset(entry, 0, sizeof(struct bt_mesh_sensor_series_entry));
|
||
return sensor_value_decode(buf, type, entry->value);
|
||
}
|
||
|
||
return sensor_column_decode(buf, type, &entry->column, entry->value);
|
||
}
|
||
|
||
static int handle_column_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
struct series_data_rsp *rsp;
|
||
const struct bt_mesh_sensor_format *col_format;
|
||
const struct bt_mesh_sensor_type *type;
|
||
int err;
|
||
|
||
uint16_t id = net_buf_simple_pull_le16(buf);
|
||
|
||
type = bt_mesh_sensor_type_get(id);
|
||
if (!type) {
|
||
unknown_type(cli, ctx, id, BT_MESH_SENSOR_OP_COLUMN_STATUS);
|
||
return -ENOENT;
|
||
}
|
||
|
||
struct bt_mesh_sensor_series_entry entry;
|
||
|
||
col_format = bt_mesh_sensor_column_format_get(type);
|
||
|
||
err = parse_series_entry(type, col_format, buf, &entry);
|
||
if (err == -ENOENT) {
|
||
/* The entry doesn't exist */
|
||
goto yield_ack;
|
||
}
|
||
|
||
if (err) {
|
||
return err; /* Invalid format, should ignore message */
|
||
}
|
||
|
||
if (cli->cb && cli->cb->series_entry) {
|
||
cli->cb->series_entry(cli, ctx, type, 0, 1, &entry);
|
||
}
|
||
|
||
yield_ack:
|
||
if (bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_COLUMN_STATUS, ctx->addr,
|
||
(void **)&rsp)) {
|
||
/* If column format exists verify Raw Value A */
|
||
if (col_format &&
|
||
(rsp->col->start.val1 != entry.column.start.val1 ||
|
||
rsp->col->start.val2 != entry.column.start.val2)) {
|
||
return 0;
|
||
}
|
||
|
||
if (err) {
|
||
rsp->count = 0;
|
||
} else {
|
||
rsp->entries[0] = entry;
|
||
rsp->count = 1;
|
||
}
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int handle_series_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
const struct bt_mesh_sensor_format *col_format;
|
||
const struct bt_mesh_sensor_type *type;
|
||
struct series_data_rsp *rsp = NULL;
|
||
|
||
uint16_t id = net_buf_simple_pull_le16(buf);
|
||
|
||
type = bt_mesh_sensor_type_get(id);
|
||
if (!type) {
|
||
unknown_type(cli, ctx, id, BT_MESH_SENSOR_OP_SERIES_STATUS);
|
||
return -ENOENT;
|
||
}
|
||
|
||
if (bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_SERIES_STATUS, ctx->addr,
|
||
(void **)&rsp)) {
|
||
if (rsp->id != id) {
|
||
rsp = NULL;
|
||
}
|
||
}
|
||
|
||
size_t val_len = sensor_value_len(type);
|
||
|
||
col_format = bt_mesh_sensor_column_format_get(type);
|
||
if (col_format != NULL) {
|
||
val_len += (col_format->size * 2);
|
||
}
|
||
|
||
if (!val_len) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
uint8_t count = buf->len / val_len;
|
||
|
||
for (uint8_t i = 0; i < count; i++) {
|
||
struct bt_mesh_sensor_series_entry entry;
|
||
int err;
|
||
|
||
err = parse_series_entry(type, col_format, buf, &entry);
|
||
if (err) {
|
||
log_error("Failed parsing column %u (err: %d)", i, err);
|
||
return err;
|
||
}
|
||
|
||
if (cli->cb && cli->cb->series_entry) {
|
||
cli->cb->series_entry(cli, ctx, type, i, count, &entry);
|
||
}
|
||
|
||
if (rsp && i < rsp->count) {
|
||
rsp->entries[i] = entry;
|
||
}
|
||
}
|
||
|
||
if (rsp) {
|
||
rsp->count = count;
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int handle_cadence_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
struct cadence_rsp *rsp;
|
||
int err;
|
||
|
||
uint16_t id = net_buf_simple_pull_le16(buf);
|
||
const struct bt_mesh_sensor_type *type = bt_mesh_sensor_type_get(id);
|
||
|
||
if (!type) {
|
||
unknown_type(cli, ctx, id, BT_MESH_SENSOR_OP_CADENCE_STATUS);
|
||
return -ENOENT;
|
||
}
|
||
|
||
if (buf->len == 0 || type->channel_count != 1) {
|
||
log_error("Type 0x%04x doesn't support cadence", id);
|
||
err = -ENOTSUP;
|
||
goto yield_ack;
|
||
}
|
||
|
||
struct bt_mesh_sensor_cadence_status cadence;
|
||
|
||
err = sensor_cadence_decode(buf, type, &cadence.fast_period_div,
|
||
&cadence.min_int, &cadence.threshold);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
if (cli->cb && cli->cb->cadence) {
|
||
cli->cb->cadence(cli, ctx, type, &cadence);
|
||
}
|
||
|
||
yield_ack:
|
||
if (bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_CADENCE_STATUS, ctx->addr,
|
||
(void **)&rsp) &&
|
||
rsp->id == id) {
|
||
if (err) {
|
||
rsp->cadence = NULL;
|
||
} else {
|
||
*rsp->cadence = cadence;
|
||
}
|
||
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int handle_settings_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
struct settings_rsp *rsp;
|
||
|
||
if (buf->len % 2) {
|
||
return -EMSGSIZE;
|
||
}
|
||
|
||
uint16_t id = net_buf_simple_pull_le16(buf);
|
||
const struct bt_mesh_sensor_type *type = bt_mesh_sensor_type_get(id);
|
||
|
||
if (!type) {
|
||
unknown_type(cli, ctx, id, BT_MESH_SENSOR_OP_SETTINGS_STATUS);
|
||
return -ENOENT;
|
||
}
|
||
|
||
/* The list may be unaligned: */
|
||
uint16_t ids[(BT_MESH_RX_SDU_MAX -
|
||
BT_MESH_MODEL_OP_LEN(BT_MESH_SENSOR_OP_SETTINGS_STATUS) -
|
||
2) /
|
||
sizeof(uint16_t)];
|
||
uint32_t count = buf->len / 2;
|
||
|
||
memcpy(ids, net_buf_simple_pull_mem(buf, buf->len),
|
||
count * sizeof(uint16_t));
|
||
|
||
if (cli->cb && cli->cb->settings) {
|
||
cli->cb->settings(cli, ctx, type, ids, count);
|
||
}
|
||
|
||
if (bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_SETTINGS_STATUS, ctx->addr,
|
||
(void **)&rsp) &&
|
||
rsp->id == id) {
|
||
memcpy(rsp->ids, ids, sizeof(uint16_t) * MIN(count, rsp->count));
|
||
rsp->count = count;
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int handle_setting_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
|
||
struct net_buf_simple *buf)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
struct setting_rsp *rsp;
|
||
int err;
|
||
|
||
uint16_t id = net_buf_simple_pull_le16(buf);
|
||
uint16_t setting_id = net_buf_simple_pull_le16(buf);
|
||
struct bt_mesh_sensor_setting_status setting = { 0 };
|
||
uint8_t access;
|
||
|
||
if (buf->len == 0) {
|
||
goto yield_ack;
|
||
}
|
||
|
||
access = net_buf_simple_pull_u8(buf);
|
||
if (access != 0x01 && access != 0x03) {
|
||
return -EINVAL;
|
||
}
|
||
|
||
const struct bt_mesh_sensor_type *type = bt_mesh_sensor_type_get(id);
|
||
|
||
if (!type) {
|
||
unknown_type(cli, ctx, id, BT_MESH_SENSOR_OP_SETTING_STATUS);
|
||
return -ENOENT;
|
||
}
|
||
|
||
|
||
setting.type = bt_mesh_sensor_type_get(setting_id);
|
||
if (!setting.type) {
|
||
unknown_type(
|
||
cli, ctx, setting_id, BT_MESH_SENSOR_OP_SETTING_STATUS);
|
||
return -ENOENT;
|
||
}
|
||
|
||
setting.writable = (access == 0x03);
|
||
|
||
/* If we attempted setting an unwritable value, the server omits the
|
||
* setting value. This is a legal response, but it should make the set()
|
||
* function return -EACCES.
|
||
*/
|
||
if (buf->len == 0 && !setting.writable) {
|
||
goto yield_ack;
|
||
}
|
||
|
||
err = sensor_value_decode(buf, setting.type, setting.value);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
if (cli->cb && cli->cb->setting_status) {
|
||
cli->cb->setting_status(cli, ctx, type, &setting);
|
||
}
|
||
|
||
yield_ack:
|
||
if (bt_mesh_msg_ack_ctx_match(&cli->ack_ctx, BT_MESH_SENSOR_OP_SETTING_STATUS, ctx->addr,
|
||
(void **)&rsp) &&
|
||
rsp->id == id && rsp->setting_id == setting_id) {
|
||
*rsp->setting = setting;
|
||
bt_mesh_msg_ack_ctx_rx(&cli->ack_ctx);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
const struct bt_mesh_model_op _bt_mesh_sensor_cli_op[] = {
|
||
{
|
||
BT_MESH_SENSOR_OP_DESCRIPTOR_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_DESCRIPTOR_STATUS),
|
||
handle_descriptor_status,
|
||
},
|
||
{
|
||
BT_MESH_SENSOR_OP_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_STATUS),
|
||
handle_status,
|
||
},
|
||
{
|
||
BT_MESH_SENSOR_OP_COLUMN_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_COLUMN_STATUS),
|
||
handle_column_status,
|
||
},
|
||
{
|
||
BT_MESH_SENSOR_OP_SERIES_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_SERIES_STATUS),
|
||
handle_series_status,
|
||
},
|
||
{
|
||
BT_MESH_SENSOR_OP_CADENCE_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_CADENCE_STATUS),
|
||
handle_cadence_status,
|
||
},
|
||
{
|
||
BT_MESH_SENSOR_OP_SETTINGS_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_SETTINGS_STATUS),
|
||
handle_settings_status,
|
||
},
|
||
{
|
||
BT_MESH_SENSOR_OP_SETTING_STATUS,
|
||
BT_MESH_LEN_MIN(BT_MESH_SENSOR_MSG_MINLEN_SETTING_STATUS),
|
||
handle_setting_status,
|
||
},
|
||
BT_MESH_MODEL_OP_END,
|
||
};
|
||
|
||
static int sensor_cli_init(struct bt_mesh_model *model)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
|
||
cli->model = model;
|
||
cli->pub.msg = &cli->pub_buf;
|
||
net_buf_simple_init_with_data(&cli->pub_buf, cli->pub_data,
|
||
sizeof(cli->pub_data));
|
||
bt_mesh_msg_ack_ctx_init(&cli->ack_ctx);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static void sensor_cli_reset(struct bt_mesh_model *model)
|
||
{
|
||
struct bt_mesh_sensor_cli *cli = model->rt->user_data;
|
||
|
||
net_buf_simple_reset(cli->pub.msg);
|
||
bt_mesh_msg_ack_ctx_reset(&cli->ack_ctx);
|
||
}
|
||
|
||
const struct bt_mesh_model_cb _bt_mesh_sensor_cli_cb = {
|
||
.init = sensor_cli_init,
|
||
.reset = sensor_cli_reset,
|
||
};
|
||
|
||
int bt_mesh_sensor_cli_desc_all_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
struct bt_mesh_sensor_info *sensors,
|
||
uint32_t *count)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_DESCRIPTOR_GET,
|
||
BT_MESH_SENSOR_MSG_MINLEN_DESCRIPTOR_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_DESCRIPTOR_GET);
|
||
|
||
struct list_rsp list_rsp = {
|
||
.sensors = sensors,
|
||
.count = count ? *count : 0,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_DESCRIPTOR_STATUS,
|
||
.user_data = &list_rsp,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, sensors ? &rsp_ctx : NULL);
|
||
if (count && !err) {
|
||
*count = list_rsp.count;
|
||
}
|
||
|
||
return err;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_desc_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
struct bt_mesh_sensor_descriptor *rsp)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_DESCRIPTOR_GET,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_DESCRIPTOR_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_DESCRIPTOR_GET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
struct bt_mesh_sensor_info info = {
|
||
sensor->id,
|
||
};
|
||
struct list_rsp list_rsp = {
|
||
.sensors = &info,
|
||
.count = 1,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_DESCRIPTOR_STATUS,
|
||
.user_data = &list_rsp,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
if (list_rsp.count == 0) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
*rsp = info.descriptor;
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_cadence_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
struct bt_mesh_sensor_cadence_status *rsp)
|
||
{
|
||
if (sensor->channel_count != 1) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_CADENCE_GET, 2);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_CADENCE_GET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
struct cadence_rsp rsp_data = {
|
||
.id = sensor->id,
|
||
.cadence = rsp,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_CADENCE_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
/* Status handler clears the cadence member if server indicates that
|
||
* cadence isn't supported.
|
||
*/
|
||
if (!rsp_data.cadence) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_cadence_set(
|
||
struct bt_mesh_sensor_cli *cli, struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_cadence_status *cadence,
|
||
struct bt_mesh_sensor_cadence_status *rsp)
|
||
{
|
||
if (sensor->channel_count != 1) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_CADENCE_SET,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_CADENCE_SET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_CADENCE_SET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
struct cadence_rsp rsp_data = {
|
||
.id = sensor->id,
|
||
.cadence = rsp,
|
||
};
|
||
|
||
err = sensor_cadence_encode(&msg, sensor, cadence->fast_period_div,
|
||
cadence->min_int, &cadence->threshold);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_CADENCE_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
/* Status handler clears the cadence member if server indicates that
|
||
* cadence isn't supported.
|
||
*/
|
||
if (!rsp_data.cadence) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_cadence_set_unack(
|
||
struct bt_mesh_sensor_cli *cli, struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_cadence_status *cadence)
|
||
{
|
||
if (sensor->channel_count != 1) {
|
||
return -ENOTSUP;
|
||
}
|
||
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg,
|
||
BT_MESH_SENSOR_OP_CADENCE_SET_UNACKNOWLEDGED,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_CADENCE_SET);
|
||
bt_mesh_model_msg_init(&msg,
|
||
BT_MESH_SENSOR_OP_CADENCE_SET_UNACKNOWLEDGED);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
err = sensor_cadence_encode(&msg, sensor, cadence->fast_period_div,
|
||
cadence->min_int, &cadence->threshold);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
return bt_mesh_msg_send(cli->model, ctx, &msg);
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_settings_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
uint16_t *ids, uint32_t *count)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_SETTINGS_GET,
|
||
BT_MESH_SENSOR_MSG_LEN_SETTINGS_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_SETTINGS_GET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
struct settings_rsp rsp = {
|
||
.id = sensor->id,
|
||
.ids = ids,
|
||
.count = count ? *count : 0,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_SETTINGS_STATUS,
|
||
.user_data = &rsp,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, ids ? &rsp_ctx : NULL);
|
||
if (!count || err) {
|
||
return err;
|
||
}
|
||
|
||
*count = rsp.count;
|
||
|
||
return err;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_setting_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_type *setting,
|
||
struct bt_mesh_sensor_setting_status *rsp)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_SETTING_GET,
|
||
BT_MESH_SENSOR_MSG_LEN_SETTING_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_SETTING_GET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
net_buf_simple_add_le16(&msg, setting->id);
|
||
|
||
struct setting_rsp rsp_data = {
|
||
.id = sensor->id,
|
||
.setting_id = setting->id,
|
||
.setting = rsp,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_SETTING_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
if (!rsp->type) {
|
||
return -ENOENT;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_setting_set(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_type *setting,
|
||
const struct sensor_value *value,
|
||
struct bt_mesh_sensor_setting_status *rsp)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_SETTING_SET,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_SETTING_SET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_SETTING_SET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
net_buf_simple_add_le16(&msg, setting->id);
|
||
err = sensor_value_encode(&msg, setting, value);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
struct setting_rsp rsp_data = {
|
||
.id = sensor->id,
|
||
.setting_id = setting->id,
|
||
.setting = rsp,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_SETTING_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
if (!rsp->type) {
|
||
return -ENOENT;
|
||
}
|
||
|
||
if (!rsp->writable) {
|
||
return -EACCES;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_setting_set_unack(
|
||
struct bt_mesh_sensor_cli *cli, struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_type *setting,
|
||
const struct sensor_value *value)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_SETTING_SET_UNACKNOWLEDGED,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_SETTING_SET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_SETTING_SET_UNACKNOWLEDGED);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
net_buf_simple_add_le16(&msg, setting->id);
|
||
err = sensor_value_encode(&msg, setting, value);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
return bt_mesh_msg_send(cli->model, ctx, &msg);
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_all_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
struct bt_mesh_sensor_data *sensors,
|
||
uint32_t *count)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_GET,
|
||
BT_MESH_SENSOR_MSG_MINLEN_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_GET);
|
||
|
||
struct sensor_data_list_rsp rsp_data = { .count = count ? *count : 0,
|
||
.sensors = sensors
|
||
};
|
||
|
||
if (sensors && count) {
|
||
memset(sensors, 0, sizeof(*sensors) * (*count));
|
||
}
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, sensors ? &rsp_ctx : NULL);
|
||
if (!count || err) {
|
||
return err;
|
||
}
|
||
|
||
if (rsp_data.count == 0) {
|
||
return -ENODEV;
|
||
}
|
||
|
||
*count = rsp_data.count;
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_get(struct bt_mesh_sensor_cli *cli,
|
||
struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
struct sensor_value *rsp)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_GET,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_GET);
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
struct bt_mesh_sensor_data sensor_data = {
|
||
.type = sensor,
|
||
};
|
||
struct sensor_data_list_rsp rsp_data = { .count = 1,
|
||
.sensors = &sensor_data
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
if (!sensor_data.type) {
|
||
return -ENODEV;
|
||
}
|
||
|
||
memcpy(rsp, sensor_data.value, sizeof(struct sensor_value) * sensor->channel_count);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_series_entry_get(
|
||
struct bt_mesh_sensor_cli *cli, struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_column *column,
|
||
struct bt_mesh_sensor_series_entry *rsp)
|
||
{
|
||
const struct bt_mesh_sensor_format *col_format;
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_COLUMN_GET,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_COLUMN_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_COLUMN_GET);
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
col_format = bt_mesh_sensor_column_format_get(sensor);
|
||
if (col_format == NULL) {
|
||
net_buf_simple_add_le16(&msg, column->start.val1);
|
||
} else {
|
||
err = sensor_ch_encode(&msg, col_format, &column->start);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
}
|
||
|
||
struct series_data_rsp rsp_data = {
|
||
.entries = rsp,
|
||
.id = sensor->id,
|
||
.count = 1,
|
||
.col = column,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_COLUMN_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!rsp || err) {
|
||
return err;
|
||
}
|
||
|
||
if (rsp_data.count == 0) {
|
||
return -ENOENT;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bt_mesh_sensor_cli_series_entries_get(
|
||
struct bt_mesh_sensor_cli *cli, struct bt_mesh_msg_ctx *ctx,
|
||
const struct bt_mesh_sensor_type *sensor,
|
||
const struct bt_mesh_sensor_column *range,
|
||
struct bt_mesh_sensor_series_entry *rsp, uint32_t *count)
|
||
{
|
||
int err;
|
||
|
||
BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_SENSOR_OP_SERIES_GET,
|
||
BT_MESH_SENSOR_MSG_MAXLEN_SERIES_GET);
|
||
bt_mesh_model_msg_init(&msg, BT_MESH_SENSOR_OP_SERIES_GET);
|
||
|
||
net_buf_simple_add_le16(&msg, sensor->id);
|
||
|
||
if (range) {
|
||
const struct bt_mesh_sensor_format *col_format;
|
||
|
||
col_format = bt_mesh_sensor_column_format_get(sensor);
|
||
|
||
if (!col_format) {
|
||
net_buf_simple_add_le16(&msg, range->start.val1);
|
||
net_buf_simple_add_le16(&msg, range->end.val1);
|
||
} else {
|
||
err = sensor_ch_encode(&msg, col_format, &range->start);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
err = sensor_ch_encode(&msg, col_format, &range->end);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
}
|
||
}
|
||
|
||
struct series_data_rsp rsp_data = {
|
||
.entries = rsp,
|
||
.id = sensor->id,
|
||
.count = count ? *count : 0,
|
||
};
|
||
|
||
struct bt_mesh_msg_rsp_ctx rsp_ctx = {
|
||
.ack = &cli->ack_ctx,
|
||
.op = BT_MESH_SENSOR_OP_SERIES_STATUS,
|
||
.user_data = &rsp_data,
|
||
.timeout = model_ackd_timeout_get(cli->model, ctx),
|
||
};
|
||
|
||
err = bt_mesh_msg_ackd_send(cli->model, ctx, &msg, rsp ? &rsp_ctx : NULL);
|
||
if (!count || err) {
|
||
return err;
|
||
}
|
||
|
||
*count = rsp_data.count;
|
||
|
||
return 0;
|
||
}
|
||
#endif |