Hi NRF team,
I am working on the NRF52840 dev board with Zephyr OS.
My requirement is to create a BLE central device which can connect with my peripheral and discover all the services.
Then after discovering all the services, central device should subscribe characteristics. And I should get notification events from all peripheral services.
I have used 2 NRF connect boards. I have flashed peripheral_hr example code(zephyrproject/zephyr/samples/bluetooth/peripheral_hr) in one board. And in other board I have flashed central_hr example code(zephyrproject/zephyr/samples/bluetooth/central_hr) in another broad.
I have checked different services by using NRF connect application. So here peripheral_hr is having the heart rate profile. So it contains Heart rate service and Battery service.
From the NRF connect application I am able to connect and subscribe both services and able to get notification data from peripheral device.
Now I have checked same scenario with another NRF dev board which having the central application(central_hr). By using this app I am able to connect with my peripheral device.
Also I am able to subscribe the heart rate service and I am able to get notification data from peripheral. Please find below logs.
Now in the central code battery service implementation is missing for heart rate profile so I have added the code to discover the battery service and also added code for the notification
for battery service for heart rate profile.
Here I am facing one issue. I am able to discover the battery and heart rate service. Also I am able to write the notify descriptor to battery level and heart rate measurement characteristics.
But I am getting notification only from heart rate measurement characteristics not from battery level characteristics.
Please find below logs.
I have also attached my code for central application. Please let me know if I am missing something.
/* main.c - Application main entry point */
/*
* Copyright (c) 2015-2016 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/sys/byteorder.h>
static void start_scan(void);
static struct bt_conn *default_conn;
static struct bt_uuid_16 discover_uuid[2] = {BT_UUID_INIT_16(0), BT_UUID_INIT_16(0)};
static struct bt_gatt_discover_params discover_params[2];
static struct bt_gatt_subscribe_params subscribe_params[2];
static uint8_t notify_func(struct bt_conn *conn,
struct bt_gatt_subscribe_params *params,
const void *data, uint16_t length)
{
if (!data) {
printk("[UNSUBSCRIBED]\n");
params->value_handle = 0U;
return BT_GATT_ITER_STOP;
}
printk("[BATTERY NOTIFICATION] data %p length %u\n", data, length);
return BT_GATT_ITER_CONTINUE;
}
static uint8_t notify_func_1(struct bt_conn *conn,
struct bt_gatt_subscribe_params *params,
const void *data, uint16_t length)
{
if (!data) {
printk("[UNSUBSCRIBED]\n");
params->value_handle = 0U;
return BT_GATT_ITER_STOP;
}
printk("[HEART RATE NOTIFICATION] data %p length %u\n", data, length);
return BT_GATT_ITER_CONTINUE;
}
static uint8_t discover_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
int err;
if (!attr) {
printk("Discover complete\n");
(void)memset(params, 0, sizeof(*params));
return BT_GATT_ITER_STOP;
}
printk("[ATTRIBUTE] handle for Battery %u\n", attr->handle);
if (!bt_uuid_cmp(discover_params[0].uuid, BT_UUID_BAS)) {
memcpy(&discover_uuid[0], BT_UUID_BAS_BATTERY_LEVEL, sizeof(discover_uuid[0]));
discover_params[0].uuid = &discover_uuid[0].uuid;
discover_params[0].start_handle = attr->handle + 1;
discover_params[0].type = BT_GATT_DISCOVER_CHARACTERISTIC;
err = bt_gatt_discover(conn, &discover_params[0]);
if (err) {
printk("Discover failed (err %d)\n", err);
}
} else if (!bt_uuid_cmp(discover_params[0].uuid,
BT_UUID_BAS_BATTERY_LEVEL)) {
memcpy(&discover_uuid[0], BT_UUID_GATT_CCC, sizeof(discover_uuid[0]));
discover_params[0].uuid = &discover_uuid[0].uuid;
discover_params[0].start_handle = attr->handle + 2;
discover_params[0].type = BT_GATT_DISCOVER_DESCRIPTOR;
subscribe_params[0].value_handle = bt_gatt_attr_value_handle(attr);
err = bt_gatt_discover(conn, &discover_params[0]);
if (err) {
printk("Discover failed (err %d)\n", err);
}
} else {
subscribe_params[0].notify = notify_func;
subscribe_params[0].value = BT_GATT_CCC_NOTIFY;
subscribe_params[0].ccc_handle = attr->handle;
err = bt_gatt_subscribe(conn, &subscribe_params[0]);
if (err && err != -EALREADY) {
printk("Subscribe failed (err %d)\n", err);
} else {
printk("[SUBSCRIBED 1]\n");
}
return BT_GATT_ITER_STOP;
}
return BT_GATT_ITER_STOP;
}
static uint8_t discover_func_1(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
int err;
if (!attr) {
printk("Discover complete\n");
(void)memset(params, 0, sizeof(*params));
return BT_GATT_ITER_STOP;
}
printk("[ATTRIBUTE] handle for Heart rate%u\n", attr->handle);
if (!bt_uuid_cmp(discover_params[1].uuid, BT_UUID_HRS)) {
memcpy(&discover_uuid[1], BT_UUID_HRS_MEASUREMENT, sizeof(discover_uuid[1]));
discover_params[1].uuid = &discover_uuid[1].uuid;
discover_params[1].start_handle = attr->handle + 1;
discover_params[1].type = BT_GATT_DISCOVER_CHARACTERISTIC;
err = bt_gatt_discover(conn, &discover_params[1]);
if (err) {
printk("Discover failed (err %d)\n", err);
}
} else if (!bt_uuid_cmp(discover_params[1].uuid,
BT_UUID_HRS_MEASUREMENT)) {
memcpy(&discover_uuid[1], BT_UUID_GATT_CCC, sizeof(discover_uuid[1]));
discover_params[1].uuid = &discover_uuid[1].uuid;
discover_params[1].start_handle = attr->handle + 2;
discover_params[1].type = BT_GATT_DISCOVER_DESCRIPTOR;
subscribe_params[1].value_handle = bt_gatt_attr_value_handle(attr);
err = bt_gatt_discover(conn, &discover_params[1]);
if (err) {
printk("Discover failed (err %d)\n", err);
}
} else {
subscribe_params[1].notify = notify_func_1;
subscribe_params[1].value = BT_GATT_CCC_NOTIFY;
subscribe_params[1].ccc_handle = attr->handle;
err = bt_gatt_subscribe(conn, &subscribe_params[1]);
if (err && err != -EALREADY) {
printk("Subscribe failed (err %d)\n", err);
} else {
printk("[SUBSCRIBED]\n");
}
return BT_GATT_ITER_STOP;
}
return BT_GATT_ITER_STOP;
}
static bool eir_found(struct bt_data *data, void *user_data)
{
bt_addr_le_t *addr = user_data;
int i;
printk("[AD]: %u data_len %u\n", data->type, data->data_len);
switch (data->type) {
case BT_DATA_UUID16_SOME:
case BT_DATA_UUID16_ALL:
if (data->data_len % sizeof(uint16_t) != 0U) {
printk("AD malformed\n");
return true;
}
for (i = 0; i < data->data_len; i += sizeof(uint16_t)) {
struct bt_le_conn_param *param;
struct bt_uuid *uuid;
uint16_t u16;
int err;
memcpy(&u16, &data->data[i], sizeof(u16));
uuid = BT_UUID_DECLARE_16(sys_le16_to_cpu(u16));
if (bt_uuid_cmp(uuid, BT_UUID_HRS)) {
continue;
}
err = bt_le_scan_stop();
if (err) {
printk("Stop LE scan failed (err %d)\n", err);
continue;
}
param = BT_LE_CONN_PARAM_DEFAULT;
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
param, &default_conn);
if (err) {
printk("Create conn failed (err %d)\n", err);
start_scan();
}
return false;
}
}
return true;
}
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
struct net_buf_simple *ad)
{
char dev[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(addr, dev, sizeof(dev));
printk("[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i\n",
dev, type, ad->len, rssi);
/* We're only interested in connectable events */
if (type == BT_GAP_ADV_TYPE_ADV_IND ||
type == BT_GAP_ADV_TYPE_ADV_DIRECT_IND) {
bt_data_parse(ad, eir_found, (void *)addr);
}
}
static void start_scan(void)
{
int err;
/* Use active scanning and disable duplicate filtering to handle any
* devices that might update their advertising data at runtime. */
struct bt_le_scan_param scan_param = {
.type = BT_LE_SCAN_TYPE_ACTIVE,
.options = BT_LE_SCAN_OPT_NONE,
.interval = BT_GAP_SCAN_FAST_INTERVAL,
.window = BT_GAP_SCAN_FAST_WINDOW,
};
err = bt_le_scan_start(&scan_param, device_found);
if (err) {
printk("Scanning failed to start (err %d)\n", err);
return;
}
printk("Scanning successfully started\n");
}
static void connected(struct bt_conn *conn, uint8_t conn_err)
{
char addr[BT_ADDR_LE_STR_LEN];
int err;
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (conn_err) {
printk("Failed to connect to %s (%u)\n", addr, conn_err);
bt_conn_unref(default_conn);
default_conn = NULL;
start_scan();
return;
}
printk("Connected: %s\n", addr);
if (conn == default_conn) {
memcpy(&discover_uuid[1], BT_UUID_HRS, sizeof(discover_uuid[1]));
discover_params[1].uuid = &discover_uuid[1].uuid;
discover_params[1].func = discover_func_1;
discover_params[1].start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
discover_params[1].end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
discover_params[1].type = BT_GATT_DISCOVER_PRIMARY;
err = bt_gatt_discover(default_conn, &discover_params[1]);
if (err) {
printk("Discover failed(err %d)\n", err);
return;
}
memcpy(&discover_uuid[0], BT_UUID_BAS, sizeof(discover_uuid[0]));
discover_params[0].uuid = &discover_uuid[1].uuid;
discover_params[0].func = discover_func;
discover_params[0].start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
discover_params[0].end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
discover_params[0].type = BT_GATT_DISCOVER_PRIMARY;
err = bt_gatt_discover(default_conn, &discover_params[0]);
if (err) {
printk("Discover failed for battery(err %d)\n", err);
return;
}
}
}
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Disconnected: %s (reason 0x%02x)\n", addr, reason);
if (default_conn != conn) {
return;
}
bt_conn_unref(default_conn);
default_conn = NULL;
start_scan();
}
BT_CONN_CB_DEFINE(conn_callbacks) = {
.connected = connected,
.disconnected = disconnected,
};
int main(void)
{
int err;
err = bt_enable(NULL);
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return 0;
}
printk("Bluetooth initialized\n");
start_scan();
return 0;
}
